/**
 * 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, ...
 */

import '@girs/gjs';

// Module dependencies
import type xlib from '@girs/xlib-2.0';
import type Gdk from '@girs/gdk-3.0';
import type cairo from 'cairo';
import type GObject from '@girs/gobject-2.0';
import type GLib from '@girs/glib-2.0';
import type Pango from '@girs/pango-1.0';
import type HarfBuzz from '@girs/harfbuzz-0.0';
import type freetype2 from '@girs/freetype2-2.0';
import type Gio from '@girs/gio-2.0';
import type GModule from '@girs/gmodule-2.0';
import type GdkPixbuf from '@girs/gdkpixbuf-2.0';
import type Atk from '@girs/atk-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: string): 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 signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'activate-link': (arg0: string) => boolean | void;
            'notify::artists': (pspec: GObject.ParamSpec) => void;
            'notify::authors': (pspec: GObject.ParamSpec) => void;
            'notify::comments': (pspec: GObject.ParamSpec) => void;
            'notify::copyright': (pspec: GObject.ParamSpec) => void;
            'notify::documenters': (pspec: GObject.ParamSpec) => void;
            'notify::license': (pspec: GObject.ParamSpec) => void;
            'notify::license-type': (pspec: GObject.ParamSpec) => void;
            'notify::logo': (pspec: GObject.ParamSpec) => void;
            'notify::logo-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::program-name': (pspec: GObject.ParamSpec) => void;
            'notify::translator-credits': (pspec: GObject.ParamSpec) => void;
            'notify::version': (pspec: GObject.ParamSpec) => void;
            'notify::website': (pspec: GObject.ParamSpec) => void;
            'notify::website-label': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-license': (pspec: GObject.ParamSpec) => void;
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AboutDialog.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<AboutDialog.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): AboutDialog;

        // Signals

        connect<K extends keyof AboutDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AboutDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AboutDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AboutDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AboutDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AboutDialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'accel-activate': (arg0: GObject.Object, arg1: number, arg2: Gdk.ModifierType) => boolean | void;
            'accel-changed': (arg0: number, arg1: Gdk.ModifierType, arg2: GObject.Closure) => void;
            'notify::is-locked': (pspec: GObject.ParamSpec) => void;
            'notify::modifier-mask': (pspec: GObject.ParamSpec) => void;
            'accel-activate::is-locked': (arg0: GObject.Object, arg1: number, arg2: Gdk.ModifierType) => boolean | void;
            'accel-activate::modifier-mask': (
                arg0: GObject.Object,
                arg1: number,
                arg2: Gdk.ModifierType,
            ) => boolean | void;
            'accel-changed::is-locked': (arg0: number, arg1: Gdk.ModifierType, arg2: GObject.Closure) => void;
            'accel-changed::modifier-mask': (arg0: number, arg1: Gdk.ModifierType, arg2: 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AccelGroup.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<AccelGroup.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): AccelGroup;

        // Signals

        connect<K extends keyof AccelGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AccelGroup.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AccelGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AccelGroup.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AccelGroup.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AccelGroup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Label.SignalSignatures {
            'notify::accel-closure': (pspec: GObject.ParamSpec) => void;
            'notify::accel-widget': (pspec: GObject.ParamSpec) => void;
            'notify::angle': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::cursor-position': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::justify': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::lines': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonic-keyval': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonic-widget': (pspec: GObject.ParamSpec) => void;
            'notify::pattern': (pspec: GObject.ParamSpec) => void;
            'notify::selectable': (pspec: GObject.ParamSpec) => void;
            'notify::selection-bound': (pspec: GObject.ParamSpec) => void;
            'notify::single-line-mode': (pspec: GObject.ParamSpec) => void;
            'notify::track-visited-links': (pspec: GObject.ParamSpec) => void;
            'notify::use-markup': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::wrap': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AccelLabel.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof AccelLabel.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AccelLabel.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AccelLabel.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AccelLabel.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AccelLabel.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AccelLabel.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            changed: (arg0: string, arg1: number, arg2: 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AccelMap.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<AccelMap.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof AccelMap.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AccelMap.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AccelMap.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AccelMap.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AccelMap.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AccelMap.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Atk.Object.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Accessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Accessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Accessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Accessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Accessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Accessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Accessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Accessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            activate: () => void;
            'notify::action-group': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
            'notify::hide-if-empty': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::short-label': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-overflown': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Action.SignalSignatures;

        // 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<K extends keyof Action.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Action.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Action.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Action.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Action.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Action.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ActionBar.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ActionBar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ActionBar;

        // Signals

        connect<K extends keyof ActionBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ActionBar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ActionBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ActionBar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ActionBar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ActionBar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'connect-proxy': (arg0: Action, arg1: Widget) => void;
            'disconnect-proxy': (arg0: Action, arg1: Widget) => void;
            'post-activate': (arg0: Action) => void;
            'pre-activate': (arg0: Action) => void;
            'notify::accel-group': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ActionGroup.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ActionGroup.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](name: string): ActionGroup;

        // Signals

        connect<K extends keyof ActionGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ActionGroup.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ActionGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ActionGroup.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ActionGroup.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ActionGroup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GObject.InitiallyUnowned.SignalSignatures {
            changed: () => void;
            'value-changed': () => void;
            'notify::lower': (pspec: GObject.ParamSpec) => void;
            'notify::page-increment': (pspec: GObject.ParamSpec) => void;
            'notify::page-size': (pspec: GObject.ParamSpec) => void;
            'notify::step-increment': (pspec: GObject.ParamSpec) => void;
            'notify::upper': (pspec: GObject.ParamSpec) => void;
            'notify::value': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Adjustment.SignalSignatures;

        // 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<K extends keyof Adjustment.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Adjustment.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Adjustment.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Adjustment.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Adjustment.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Adjustment.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::bottom-padding': (pspec: GObject.ParamSpec) => void;
            'notify::left-padding': (pspec: GObject.ParamSpec) => void;
            'notify::right-padding': (pspec: GObject.ParamSpec) => void;
            'notify::top-padding': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xscale': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::yscale': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Alignment.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof Alignment.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Alignment.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Alignment.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Alignment.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Alignment.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Alignment.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends ComboBox.SignalSignatures {
            'custom-item-activated': (arg0: string) => void;
            'notify::heading': (pspec: GObject.ParamSpec) => void;
            'notify::show-default-item': (pspec: GObject.ParamSpec) => void;
            'notify::show-dialog-item': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::active-id': (pspec: GObject.ParamSpec) => void;
            'notify::add-tearoffs': (pspec: GObject.ParamSpec) => void;
            'notify::button-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::cell-area': (pspec: GObject.ParamSpec) => void;
            'notify::column-span-column': (pspec: GObject.ParamSpec) => void;
            'notify::entry-text-column': (pspec: GObject.ParamSpec) => void;
            'notify::has-entry': (pspec: GObject.ParamSpec) => void;
            'notify::has-frame': (pspec: GObject.ParamSpec) => void;
            'notify::id-column': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::popup-fixed-width': (pspec: GObject.ParamSpec) => void;
            'notify::popup-shown': (pspec: GObject.ParamSpec) => void;
            'notify::row-span-column': (pspec: GObject.ParamSpec) => void;
            'notify::tearoff-title': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-width': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::content-type': (pspec: GObject.ParamSpec) => void;
            'notify::editing-canceled': (pspec: GObject.ParamSpec) => void;
            'custom-item-activated::heading': (arg0: string) => void;
            'custom-item-activated::show-default-item': (arg0: string) => void;
            'custom-item-activated::show-dialog-item': (arg0: string) => void;
            'custom-item-activated::active': (arg0: string) => void;
            'custom-item-activated::active-id': (arg0: string) => void;
            'custom-item-activated::add-tearoffs': (arg0: string) => void;
            'custom-item-activated::button-sensitivity': (arg0: string) => void;
            'custom-item-activated::cell-area': (arg0: string) => void;
            'custom-item-activated::column-span-column': (arg0: string) => void;
            'custom-item-activated::entry-text-column': (arg0: string) => void;
            'custom-item-activated::has-entry': (arg0: string) => void;
            'custom-item-activated::has-frame': (arg0: string) => void;
            'custom-item-activated::id-column': (arg0: string) => void;
            'custom-item-activated::model': (arg0: string) => void;
            'custom-item-activated::popup-fixed-width': (arg0: string) => void;
            'custom-item-activated::popup-shown': (arg0: string) => void;
            'custom-item-activated::row-span-column': (arg0: string) => void;
            'custom-item-activated::tearoff-title': (arg0: string) => void;
            'custom-item-activated::wrap-width': (arg0: string) => void;
            'custom-item-activated::border-width': (arg0: string) => void;
            'custom-item-activated::child': (arg0: string) => void;
            'custom-item-activated::resize-mode': (arg0: string) => void;
            'custom-item-activated::app-paintable': (arg0: string) => void;
            'custom-item-activated::can-default': (arg0: string) => void;
            'custom-item-activated::can-focus': (arg0: string) => void;
            'custom-item-activated::composite-child': (arg0: string) => void;
            'custom-item-activated::double-buffered': (arg0: string) => void;
            'custom-item-activated::events': (arg0: string) => void;
            'custom-item-activated::expand': (arg0: string) => void;
            'custom-item-activated::focus-on-click': (arg0: string) => void;
            'custom-item-activated::halign': (arg0: string) => void;
            'custom-item-activated::has-default': (arg0: string) => void;
            'custom-item-activated::has-focus': (arg0: string) => void;
            'custom-item-activated::has-tooltip': (arg0: string) => void;
            'custom-item-activated::height-request': (arg0: string) => void;
            'custom-item-activated::hexpand': (arg0: string) => void;
            'custom-item-activated::hexpand-set': (arg0: string) => void;
            'custom-item-activated::is-focus': (arg0: string) => void;
            'custom-item-activated::margin': (arg0: string) => void;
            'custom-item-activated::margin-bottom': (arg0: string) => void;
            'custom-item-activated::margin-end': (arg0: string) => void;
            'custom-item-activated::margin-left': (arg0: string) => void;
            'custom-item-activated::margin-right': (arg0: string) => void;
            'custom-item-activated::margin-start': (arg0: string) => void;
            'custom-item-activated::margin-top': (arg0: string) => void;
            'custom-item-activated::name': (arg0: string) => void;
            'custom-item-activated::no-show-all': (arg0: string) => void;
            'custom-item-activated::opacity': (arg0: string) => void;
            'custom-item-activated::parent': (arg0: string) => void;
            'custom-item-activated::receives-default': (arg0: string) => void;
            'custom-item-activated::scale-factor': (arg0: string) => void;
            'custom-item-activated::sensitive': (arg0: string) => void;
            'custom-item-activated::style': (arg0: string) => void;
            'custom-item-activated::tooltip-markup': (arg0: string) => void;
            'custom-item-activated::tooltip-text': (arg0: string) => void;
            'custom-item-activated::valign': (arg0: string) => void;
            'custom-item-activated::vexpand': (arg0: string) => void;
            'custom-item-activated::vexpand-set': (arg0: string) => void;
            'custom-item-activated::visible': (arg0: string) => void;
            'custom-item-activated::width-request': (arg0: string) => void;
            'custom-item-activated::window': (arg0: string) => void;
            'custom-item-activated::content-type': (arg0: string) => void;
            'custom-item-activated::editing-canceled': (arg0: 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AppChooserButton.SignalSignatures;

        // 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<K extends keyof AppChooserButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AppChooserButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AppChooserButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AppChooserButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AppChooserButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AppChooserButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::gfile': (pspec: GObject.ParamSpec) => void;
            'notify::heading': (pspec: GObject.ParamSpec) => void;
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::content-type': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AppChooserDialog.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof AppChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AppChooserDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AppChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AppChooserDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AppChooserDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AppChooserDialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'application-activated': (arg0: Gio.AppInfo) => void;
            'application-selected': (arg0: Gio.AppInfo) => void;
            'populate-popup': (arg0: Menu, arg1: Gio.AppInfo) => void;
            'notify::default-text': (pspec: GObject.ParamSpec) => void;
            'notify::show-all': (pspec: GObject.ParamSpec) => void;
            'notify::show-default': (pspec: GObject.ParamSpec) => void;
            'notify::show-fallback': (pspec: GObject.ParamSpec) => void;
            'notify::show-other': (pspec: GObject.ParamSpec) => void;
            'notify::show-recommended': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::content-type': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AppChooserWidget.SignalSignatures;

        // 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<K extends keyof AppChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AppChooserWidget.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AppChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AppChooserWidget.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AppChooserWidget.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AppChooserWidget.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Gio.Application.SignalSignatures {
            'query-end': () => void;
            'window-added': (arg0: Window) => void;
            'window-removed': (arg0: Window) => void;
            'notify::active-window': (pspec: GObject.ParamSpec) => void;
            'notify::app-menu': (pspec: GObject.ParamSpec) => void;
            'notify::menubar': (pspec: GObject.ParamSpec) => void;
            'notify::register-session': (pspec: GObject.ParamSpec) => void;
            'notify::screensaver-active': (pspec: GObject.ParamSpec) => void;
            'notify::action-group': (pspec: GObject.ParamSpec) => void;
            'notify::application-id': (pspec: GObject.ParamSpec) => void;
            'notify::flags': (pspec: GObject.ParamSpec) => void;
            'notify::inactivity-timeout': (pspec: GObject.ParamSpec) => void;
            'notify::is-busy': (pspec: GObject.ParamSpec) => void;
            'notify::is-registered': (pspec: GObject.ParamSpec) => void;
            'notify::is-remote': (pspec: GObject.ParamSpec) => void;
            'notify::resource-base-path': (pspec: GObject.ParamSpec) => void;
            'notify::version': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Application.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](application_id: string | null, flags: Gio.ApplicationFlags): Application;

        // Signals

        connect<K extends keyof Application.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Application.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Application.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Application.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Application.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Application.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Window.SignalSignatures {
            'notify::show-menubar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ApplicationWindow.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof ApplicationWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ApplicationWindow.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ApplicationWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ApplicationWindow.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ApplicationWindow.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ApplicationWindow.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Misc.SignalSignatures {
            'notify::arrow-type': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Arrow.SignalSignatures;

        // Fields

        misc: Misc;

        // Constructors

        constructor(properties?: Partial<Arrow.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](arrow_type: ArrowType, shadow_type: ShadowType): Arrow;

        // Signals

        connect<K extends keyof Arrow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Arrow.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Arrow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Arrow.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Arrow.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Arrow.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ArrowAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ArrowAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ArrowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ArrowAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ArrowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ArrowAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ArrowAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ArrowAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Frame.SignalSignatures {
            'notify::obey-child': (pspec: GObject.ParamSpec) => void;
            'notify::ratio': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::label-xalign': (pspec: GObject.ParamSpec) => void;
            'notify::label-yalign': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: AspectFrame.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof AspectFrame.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AspectFrame.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof AspectFrame.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, AspectFrame.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof AspectFrame.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<AspectFrame.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Window.SignalSignatures {
            apply: () => void;
            cancel: () => void;
            close: () => void;
            escape: () => void;
            prepare: (arg0: Widget) => void;
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Assistant.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Assistant.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Assistant;

        // Signals

        connect<K extends keyof Assistant.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Assistant.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Assistant.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Assistant.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Assistant.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Assistant.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Bin.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Bin.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Bin.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Bin.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Bin.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Bin.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Bin.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Bin.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends RendererCellAccessible.SignalSignatures {
            'notify::renderer': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: BooleanCellAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<BooleanCellAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof BooleanCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, BooleanCellAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof BooleanCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, BooleanCellAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof BooleanCellAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<BooleanCellAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Box.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Box.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](orientation: Orientation, spacing: number): Box;

        // Signals

        connect<K extends keyof Box.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Box.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Box.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Box.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Box.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Box.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::translation-domain': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Builder.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof Builder.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Builder.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Builder.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Builder.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Builder.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Builder.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            activate: () => void;
            clicked: () => void;
            enter: () => void;
            leave: () => void;
            pressed: () => void;
            released: () => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Button.SignalSignatures;

        // 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<K extends keyof Button.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Button.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Button.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Button.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Button.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Button.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::layout-style': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ButtonBox.SignalSignatures;

        // Fields

        box: Box;

        // Constructors

        constructor(properties?: Partial<ButtonBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](orientation: Orientation): ButtonBox;

        // Signals

        connect<K extends keyof ButtonBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ButtonBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ButtonBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ButtonBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ButtonBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ButtonBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'day-selected': () => void;
            'day-selected-double-click': () => void;
            'month-changed': () => void;
            'next-month': () => void;
            'next-year': () => void;
            'prev-month': () => void;
            'prev-year': () => void;
            'notify::day': (pspec: GObject.ParamSpec) => void;
            'notify::detail-height-rows': (pspec: GObject.ParamSpec) => void;
            'notify::detail-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::month': (pspec: GObject.ParamSpec) => void;
            'notify::no-month-change': (pspec: GObject.ParamSpec) => void;
            'notify::show-day-names': (pspec: GObject.ParamSpec) => void;
            'notify::show-details': (pspec: GObject.ParamSpec) => void;
            'notify::show-heading': (pspec: GObject.ParamSpec) => void;
            'notify::show-week-numbers': (pspec: GObject.ParamSpec) => void;
            'notify::year': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Calendar.SignalSignatures;

        // Fields

        widget: Widget;

        // Constructors

        constructor(properties?: Partial<Calendar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Calendar;

        // Signals

        connect<K extends keyof Calendar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Calendar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Calendar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Calendar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Calendar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Calendar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Accessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof CellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.InitiallyUnowned.SignalSignatures {
            'add-editable': (arg0: CellRenderer, arg1: CellEditable, arg2: Gdk.Rectangle, arg3: string) => void;
            'apply-attributes': (arg0: TreeModel, arg1: TreeIter, arg2: boolean, arg3: boolean) => void;
            'focus-changed': (arg0: CellRenderer, arg1: string) => void;
            'remove-editable': (arg0: CellRenderer, arg1: CellEditable) => void;
            'notify::edit-widget': (pspec: GObject.ParamSpec) => void;
            'notify::edited-cell': (pspec: GObject.ParamSpec) => void;
            'notify::focus-cell': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellArea.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellArea.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof CellArea.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellArea.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellArea.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellArea.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellArea.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellArea.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends CellArea.SignalSignatures {
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::edit-widget': (pspec: GObject.ParamSpec) => void;
            'notify::edited-cell': (pspec: GObject.ParamSpec) => void;
            'notify::focus-cell': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellAreaBox.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellAreaBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellAreaBox;

        // Signals

        connect<K extends keyof CellAreaBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellAreaBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellAreaBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellAreaBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellAreaBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellAreaBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::area': (pspec: GObject.ParamSpec) => void;
            'notify::minimum-height': (pspec: GObject.ParamSpec) => void;
            'notify::minimum-width': (pspec: GObject.ParamSpec) => void;
            'notify::natural-height': (pspec: GObject.ParamSpec) => void;
            'notify::natural-width': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellAreaContext.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellAreaContext.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof CellAreaContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellAreaContext.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellAreaContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellAreaContext.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellAreaContext.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellAreaContext.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.InitiallyUnowned.SignalSignatures {
            'editing-canceled': () => void;
            'editing-started': (arg0: CellEditable, arg1: string) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRenderer.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRenderer.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof CellRenderer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRenderer.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRenderer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRenderer.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRenderer.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRenderer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends CellRendererText.SignalSignatures {
            'accel-cleared': (arg0: string) => void;
            'accel-edited': (arg0: string, arg1: number, arg2: Gdk.ModifierType, arg3: number) => void;
            'notify::accel-key': (pspec: GObject.ParamSpec) => void;
            'notify::accel-mode': (pspec: GObject.ParamSpec) => void;
            'notify::accel-mods': (pspec: GObject.ParamSpec) => void;
            'notify::keycode': (pspec: GObject.ParamSpec) => void;
            'notify::align-set': (pspec: GObject.ParamSpec) => void;
            'notify::alignment': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::background': (pspec: GObject.ParamSpec) => void;
            'notify::background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::editable-set': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize-set': (pspec: GObject.ParamSpec) => void;
            'notify::family': (pspec: GObject.ParamSpec) => void;
            'notify::family-set': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::foreground': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-set': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::language-set': (pspec: GObject.ParamSpec) => void;
            'notify::markup': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::placeholder-text': (pspec: GObject.ParamSpec) => void;
            'notify::rise': (pspec: GObject.ParamSpec) => void;
            'notify::rise-set': (pspec: GObject.ParamSpec) => void;
            'notify::scale': (pspec: GObject.ParamSpec) => void;
            'notify::scale-set': (pspec: GObject.ParamSpec) => void;
            'notify::single-paragraph-mode': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::size-points': (pspec: GObject.ParamSpec) => void;
            'notify::size-set': (pspec: GObject.ParamSpec) => void;
            'notify::stretch': (pspec: GObject.ParamSpec) => void;
            'notify::stretch-set': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough-set': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::style-set': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::underline': (pspec: GObject.ParamSpec) => void;
            'notify::underline-set': (pspec: GObject.ParamSpec) => void;
            'notify::variant': (pspec: GObject.ParamSpec) => void;
            'notify::variant-set': (pspec: GObject.ParamSpec) => void;
            'notify::weight': (pspec: GObject.ParamSpec) => void;
            'notify::weight-set': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-width': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererAccel.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererAccel.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererAccel;

        // Signals

        connect<K extends keyof CellRendererAccel.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererAccel.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererAccel.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererAccel.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererAccel.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererAccel.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends CellRendererText.SignalSignatures {
            changed: (arg0: string, arg1: TreeIter) => void;
            'notify::has-entry': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::text-column': (pspec: GObject.ParamSpec) => void;
            'notify::align-set': (pspec: GObject.ParamSpec) => void;
            'notify::alignment': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::background': (pspec: GObject.ParamSpec) => void;
            'notify::background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::editable-set': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize-set': (pspec: GObject.ParamSpec) => void;
            'notify::family': (pspec: GObject.ParamSpec) => void;
            'notify::family-set': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::foreground': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-set': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::language-set': (pspec: GObject.ParamSpec) => void;
            'notify::markup': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::placeholder-text': (pspec: GObject.ParamSpec) => void;
            'notify::rise': (pspec: GObject.ParamSpec) => void;
            'notify::rise-set': (pspec: GObject.ParamSpec) => void;
            'notify::scale': (pspec: GObject.ParamSpec) => void;
            'notify::scale-set': (pspec: GObject.ParamSpec) => void;
            'notify::single-paragraph-mode': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::size-points': (pspec: GObject.ParamSpec) => void;
            'notify::size-set': (pspec: GObject.ParamSpec) => void;
            'notify::stretch': (pspec: GObject.ParamSpec) => void;
            'notify::stretch-set': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough-set': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::style-set': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::underline': (pspec: GObject.ParamSpec) => void;
            'notify::underline-set': (pspec: GObject.ParamSpec) => void;
            'notify::variant': (pspec: GObject.ParamSpec) => void;
            'notify::variant-set': (pspec: GObject.ParamSpec) => void;
            'notify::weight': (pspec: GObject.ParamSpec) => void;
            'notify::weight-set': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-width': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererCombo.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererCombo.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererCombo;

        // Signals

        connect<K extends keyof CellRendererCombo.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererCombo.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererCombo.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererCombo.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererCombo.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererCombo.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;
    }

    namespace CellRendererPixbuf {
        // Signal signatures
        interface SignalSignatures extends CellRenderer.SignalSignatures {
            'notify::follow-state': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::pixbuf-expander-closed': (pspec: GObject.ParamSpec) => void;
            'notify::pixbuf-expander-open': (pspec: GObject.ParamSpec) => void;
            'notify::stock-detail': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::stock-size': (pspec: GObject.ParamSpec) => void;
            'notify::surface': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererPixbuf.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererPixbuf.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererPixbuf;

        // Signals

        connect<K extends keyof CellRendererPixbuf.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererPixbuf.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererPixbuf.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererPixbuf.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererPixbuf.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererPixbuf.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;
    }

    namespace CellRendererProgress {
        // Signal signatures
        interface SignalSignatures extends CellRenderer.SignalSignatures {
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::pulse': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::text-xalign': (pspec: GObject.ParamSpec) => void;
            'notify::text-yalign': (pspec: GObject.ParamSpec) => void;
            'notify::value': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererProgress.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererProgress.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererProgress;

        // Signals

        connect<K extends keyof CellRendererProgress.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererProgress.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererProgress.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererProgress.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererProgress.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererProgress.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 CellRendererSpin {
        // Signal signatures
        interface SignalSignatures extends CellRendererText.SignalSignatures {
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::climb-rate': (pspec: GObject.ParamSpec) => void;
            'notify::digits': (pspec: GObject.ParamSpec) => void;
            'notify::align-set': (pspec: GObject.ParamSpec) => void;
            'notify::alignment': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::background': (pspec: GObject.ParamSpec) => void;
            'notify::background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::editable-set': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize-set': (pspec: GObject.ParamSpec) => void;
            'notify::family': (pspec: GObject.ParamSpec) => void;
            'notify::family-set': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::foreground': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-set': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::language-set': (pspec: GObject.ParamSpec) => void;
            'notify::markup': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::placeholder-text': (pspec: GObject.ParamSpec) => void;
            'notify::rise': (pspec: GObject.ParamSpec) => void;
            'notify::rise-set': (pspec: GObject.ParamSpec) => void;
            'notify::scale': (pspec: GObject.ParamSpec) => void;
            'notify::scale-set': (pspec: GObject.ParamSpec) => void;
            'notify::single-paragraph-mode': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::size-points': (pspec: GObject.ParamSpec) => void;
            'notify::size-set': (pspec: GObject.ParamSpec) => void;
            'notify::stretch': (pspec: GObject.ParamSpec) => void;
            'notify::stretch-set': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough-set': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::style-set': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::underline': (pspec: GObject.ParamSpec) => void;
            'notify::underline-set': (pspec: GObject.ParamSpec) => void;
            'notify::variant': (pspec: GObject.ParamSpec) => void;
            'notify::variant-set': (pspec: GObject.ParamSpec) => void;
            'notify::weight': (pspec: GObject.ParamSpec) => void;
            'notify::weight-set': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-width': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererSpin.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererSpin.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererSpin;

        // Signals

        connect<K extends keyof CellRendererSpin.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererSpin.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererSpin.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererSpin.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererSpin.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererSpin.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;
    }

    namespace CellRendererSpinner {
        // Signal signatures
        interface SignalSignatures extends CellRenderer.SignalSignatures {
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::pulse': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererSpinner.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererSpinner.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererSpinner;

        // Signals

        connect<K extends keyof CellRendererSpinner.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererSpinner.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererSpinner.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererSpinner.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererSpinner.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererSpinner.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): void;
    }

    namespace CellRendererText {
        // Signal signatures
        interface SignalSignatures extends CellRenderer.SignalSignatures {
            edited: (arg0: string, arg1: string) => void;
            'notify::align-set': (pspec: GObject.ParamSpec) => void;
            'notify::alignment': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::background': (pspec: GObject.ParamSpec) => void;
            'notify::background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::editable-set': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize-set': (pspec: GObject.ParamSpec) => void;
            'notify::family': (pspec: GObject.ParamSpec) => void;
            'notify::family-set': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::foreground': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-set': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::language-set': (pspec: GObject.ParamSpec) => void;
            'notify::markup': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::placeholder-text': (pspec: GObject.ParamSpec) => void;
            'notify::rise': (pspec: GObject.ParamSpec) => void;
            'notify::rise-set': (pspec: GObject.ParamSpec) => void;
            'notify::scale': (pspec: GObject.ParamSpec) => void;
            'notify::scale-set': (pspec: GObject.ParamSpec) => void;
            'notify::single-paragraph-mode': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::size-points': (pspec: GObject.ParamSpec) => void;
            'notify::size-set': (pspec: GObject.ParamSpec) => void;
            'notify::stretch': (pspec: GObject.ParamSpec) => void;
            'notify::stretch-set': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough-set': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::style-set': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::underline': (pspec: GObject.ParamSpec) => void;
            'notify::underline-set': (pspec: GObject.ParamSpec) => void;
            'notify::variant': (pspec: GObject.ParamSpec) => void;
            'notify::variant-set': (pspec: GObject.ParamSpec) => void;
            'notify::weight': (pspec: GObject.ParamSpec) => void;
            'notify::weight-set': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-width': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererText.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererText.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererText;

        // Signals

        connect<K extends keyof CellRendererText.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererText.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererText.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererText.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererText.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererText.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends CellRenderer.SignalSignatures {
            toggled: (arg0: string) => void;
            'notify::activatable': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::inconsistent': (pspec: GObject.ParamSpec) => void;
            'notify::indicator-size': (pspec: GObject.ParamSpec) => void;
            'notify::radio': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::cell-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::editing': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::is-expanded': (pspec: GObject.ParamSpec) => void;
            'notify::is-expander': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellRendererToggle.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CellRendererToggle.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CellRendererToggle;

        // Signals

        connect<K extends keyof CellRendererToggle.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererToggle.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellRendererToggle.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellRendererToggle.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellRendererToggle.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellRendererToggle.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'notify::background': (pspec: GObject.ParamSpec) => void;
            'notify::background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::background-set': (pspec: GObject.ParamSpec) => void;
            'notify::cell-area': (pspec: GObject.ParamSpec) => void;
            'notify::cell-area-context': (pspec: GObject.ParamSpec) => void;
            'notify::draw-sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::fit-model': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CellView.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof CellView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellView.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CellView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CellView.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CellView.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CellView.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ToggleButton.SignalSignatures {
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-indicator': (pspec: GObject.ParamSpec) => void;
            'notify::inconsistent': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CheckButton.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof CheckButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CheckButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CheckButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CheckButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CheckButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CheckButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends MenuItem.SignalSignatures {
            toggled: () => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-as-radio': (pspec: GObject.ParamSpec) => void;
            'notify::inconsistent': (pspec: GObject.ParamSpec) => void;
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::right-justified': (pspec: GObject.ParamSpec) => void;
            'notify::submenu': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CheckMenuItem.SignalSignatures;

        // 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<K extends keyof CheckMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CheckMenuItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CheckMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CheckMenuItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CheckMenuItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CheckMenuItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends MenuItemAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CheckMenuItemAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CheckMenuItemAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof CheckMenuItemAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CheckMenuItemAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CheckMenuItemAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CheckMenuItemAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CheckMenuItemAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CheckMenuItemAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'owner-change': (arg0: 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Clipboard.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Clipboard.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Clipboard.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Clipboard.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Clipboard.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Clipboard.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Clipboard.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Clipboard.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Button.SignalSignatures {
            'color-set': () => void;
            'notify::alpha': (pspec: GObject.ParamSpec) => void;
            'notify::color': (pspec: GObject.ParamSpec) => void;
            'notify::rgba': (pspec: GObject.ParamSpec) => void;
            'notify::show-editor': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::use-alpha': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ColorButton.SignalSignatures;

        // 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<K extends keyof ColorButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ColorButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ColorButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ColorButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::show-editor': (pspec: GObject.ParamSpec) => void;
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::rgba': (pspec: GObject.ParamSpec) => void;
            'notify::use-alpha': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ColorChooserDialog.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof ColorChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorChooserDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ColorChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorChooserDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ColorChooserDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ColorChooserDialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::show-editor': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::rgba': (pspec: GObject.ParamSpec) => void;
            'notify::use-alpha': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ColorChooserWidget.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ColorChooserWidget.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ColorChooserWidget;

        // Signals

        connect<K extends keyof ColorChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorChooserWidget.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ColorChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorChooserWidget.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ColorChooserWidget.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ColorChooserWidget.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'color-changed': () => void;
            'notify::current-alpha': (pspec: GObject.ParamSpec) => void;
            'notify::current-color': (pspec: GObject.ParamSpec) => void;
            'notify::current-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::has-opacity-control': (pspec: GObject.ParamSpec) => void;
            'notify::has-palette': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ColorSelection.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ColorSelection.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ColorSelection;

        // Signals

        connect<K extends keyof ColorSelection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorSelection.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ColorSelection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorSelection.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ColorSelection.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ColorSelection.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::cancel-button': (pspec: GObject.ParamSpec) => void;
            'notify::color-selection': (pspec: GObject.ParamSpec) => void;
            'notify::help-button': (pspec: GObject.ParamSpec) => void;
            'notify::ok-button': (pspec: GObject.ParamSpec) => void;
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ColorSelectionDialog.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof ColorSelectionDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorSelectionDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ColorSelectionDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ColorSelectionDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ColorSelectionDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ColorSelectionDialog.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            changed: () => void;
            'format-entry-text': (arg0: string) => string;
            'move-active': (arg0: ScrollType) => void;
            popdown: () => boolean | void;
            popup: () => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::active-id': (pspec: GObject.ParamSpec) => void;
            'notify::add-tearoffs': (pspec: GObject.ParamSpec) => void;
            'notify::button-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::cell-area': (pspec: GObject.ParamSpec) => void;
            'notify::column-span-column': (pspec: GObject.ParamSpec) => void;
            'notify::entry-text-column': (pspec: GObject.ParamSpec) => void;
            'notify::has-entry': (pspec: GObject.ParamSpec) => void;
            'notify::has-frame': (pspec: GObject.ParamSpec) => void;
            'notify::id-column': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::popup-fixed-width': (pspec: GObject.ParamSpec) => void;
            'notify::popup-shown': (pspec: GObject.ParamSpec) => void;
            'notify::row-span-column': (pspec: GObject.ParamSpec) => void;
            'notify::tearoff-title': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-width': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::editing-canceled': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ComboBox.SignalSignatures;

        // 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<K extends keyof ComboBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ComboBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ComboBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ComboBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ComboBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ComboBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ComboBoxAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ComboBoxAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ComboBoxAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ComboBoxAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ComboBoxAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ComboBoxAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ComboBoxAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ComboBoxAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends ComboBox.SignalSignatures {
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::active-id': (pspec: GObject.ParamSpec) => void;
            'notify::add-tearoffs': (pspec: GObject.ParamSpec) => void;
            'notify::button-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::cell-area': (pspec: GObject.ParamSpec) => void;
            'notify::column-span-column': (pspec: GObject.ParamSpec) => void;
            'notify::entry-text-column': (pspec: GObject.ParamSpec) => void;
            'notify::has-entry': (pspec: GObject.ParamSpec) => void;
            'notify::has-frame': (pspec: GObject.ParamSpec) => void;
            'notify::id-column': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::popup-fixed-width': (pspec: GObject.ParamSpec) => void;
            'notify::popup-shown': (pspec: GObject.ParamSpec) => void;
            'notify::row-span-column': (pspec: GObject.ParamSpec) => void;
            'notify::tearoff-title': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-width': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::editing-canceled': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ComboBoxText.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ComboBoxText.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ComboBoxText;

        static new_with_entry(): ComboBoxText;

        // Signals

        connect<K extends keyof ComboBoxText.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ComboBoxText.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ComboBoxText.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ComboBoxText.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ComboBoxText.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ComboBoxText.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            add: (arg0: Widget) => void;
            'check-resize': () => void;
            remove: (arg0: Widget) => void;
            'set-focus-child': (arg0: Widget) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Container.SignalSignatures;

        // Fields

        widget: Widget;

        // Constructors

        constructor(properties?: Partial<Container.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Container.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Container.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Container.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Container.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Container.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Container.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends WidgetAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class ContainerAccessible extends WidgetAccessible implements Atk.Component {
        static $gtype: GObject.GType<ContainerAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ContainerAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ContainerAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ContainerAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ContainerAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ContainerAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ContainerAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ContainerAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ContainerAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends CellAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ContainerCellAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ContainerCellAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ContainerCellAccessible;

        // Signals

        connect<K extends keyof ContainerCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ContainerCellAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ContainerCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ContainerCellAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ContainerCellAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ContainerCellAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'parsing-error': (arg0: CssSection, arg1: 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: CssProvider.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<CssProvider.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): CssProvider;

        // Signals

        connect<K extends keyof CssProvider.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CssProvider.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof CssProvider.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, CssProvider.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof CssProvider.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<CssProvider.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Window.SignalSignatures {
            close: () => void;
            response: (arg0: number) => void;
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Dialog.SignalSignatures;

        // 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<K extends keyof Dialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Dialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Dialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Dialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Dialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Dialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: DrawingArea.SignalSignatures;

        // Fields

        widget: Widget;

        // Constructors

        constructor(properties?: Partial<DrawingArea.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): DrawingArea;

        // Signals

        connect<K extends keyof DrawingArea.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, DrawingArea.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof DrawingArea.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, DrawingArea.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof DrawingArea.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<DrawingArea.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 Entry {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            activate: () => void;
            backspace: () => void;
            'copy-clipboard': () => void;
            'cut-clipboard': () => void;
            'delete-from-cursor': (arg0: DeleteType, arg1: number) => void;
            'icon-press': (arg0: EntryIconPosition, arg1: Gdk.Event) => void;
            'icon-release': (arg0: EntryIconPosition, arg1: Gdk.Event) => void;
            'insert-at-cursor': (arg0: string) => void;
            'insert-emoji': () => void;
            'move-cursor': (arg0: MovementStep, arg1: number, arg2: boolean) => void;
            'paste-clipboard': () => void;
            'populate-popup': (arg0: Widget) => void;
            'preedit-changed': (arg0: string) => void;
            'toggle-direction': () => void;
            'toggle-overwrite': () => void;
            'notify::activates-default': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::buffer': (pspec: GObject.ParamSpec) => void;
            'notify::caps-lock-warning': (pspec: GObject.ParamSpec) => void;
            'notify::completion': (pspec: GObject.ParamSpec) => void;
            'notify::cursor-position': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::enable-emoji-completion': (pspec: GObject.ParamSpec) => void;
            'notify::has-frame': (pspec: GObject.ParamSpec) => void;
            'notify::im-module': (pspec: GObject.ParamSpec) => void;
            'notify::inner-border': (pspec: GObject.ParamSpec) => void;
            'notify::input-hints': (pspec: GObject.ParamSpec) => void;
            'notify::input-purpose': (pspec: GObject.ParamSpec) => void;
            'notify::invisible-char': (pspec: GObject.ParamSpec) => void;
            'notify::invisible-char-set': (pspec: GObject.ParamSpec) => void;
            'notify::max-length': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::overwrite-mode': (pspec: GObject.ParamSpec) => void;
            'notify::placeholder-text': (pspec: GObject.ParamSpec) => void;
            'notify::populate-all': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-activatable': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-gicon': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-stock': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::progress-fraction': (pspec: GObject.ParamSpec) => void;
            'notify::progress-pulse-step': (pspec: GObject.ParamSpec) => void;
            'notify::scroll-offset': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-activatable': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-gicon': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-stock': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::selection-bound': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::show-emoji-icon': (pspec: GObject.ParamSpec) => void;
            'notify::tabs': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::text-length': (pspec: GObject.ParamSpec) => void;
            'notify::truncate-multiline': (pspec: GObject.ParamSpec) => void;
            'notify::visibility': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::editing-canceled': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Entry.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Entry.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Entry;

        static new_with_buffer(buffer: EntryBuffer): Entry;

        // Signals

        connect<K extends keyof Entry.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Entry.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Entry.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Entry.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Entry.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Entry.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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(): string;
        /**
         * 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: string): 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EntryAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<EntryAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof EntryAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EntryAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EntryAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EntryAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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): string;
        /**
         * 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): string;
        /**
         * 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'deleted-text': (arg0: number, arg1: number) => void;
            'inserted-text': (arg0: number, arg1: string, arg2: number) => void;
            'notify::length': (pspec: GObject.ParamSpec) => void;
            'notify::max-length': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EntryBuffer.SignalSignatures;

        // 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<K extends keyof EntryBuffer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryBuffer.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EntryBuffer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryBuffer.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EntryBuffer.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EntryBuffer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'action-activated': (arg0: number) => void;
            'cursor-on-match': (arg0: TreeModel, arg1: TreeIter) => boolean | void;
            'insert-prefix': (arg0: string) => boolean | void;
            'match-selected': (arg0: TreeModel, arg1: TreeIter) => boolean | void;
            'no-matches': () => void;
            'notify::cell-area': (pspec: GObject.ParamSpec) => void;
            'notify::inline-completion': (pspec: GObject.ParamSpec) => void;
            'notify::inline-selection': (pspec: GObject.ParamSpec) => void;
            'notify::minimum-key-length': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::popup-completion': (pspec: GObject.ParamSpec) => void;
            'notify::popup-set-width': (pspec: GObject.ParamSpec) => void;
            'notify::popup-single-match': (pspec: GObject.ParamSpec) => void;
            'notify::text-column': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EntryCompletion.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<EntryCompletion.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): EntryCompletion;

        static new_with_area(area: CellArea): EntryCompletion;

        // Signals

        connect<K extends keyof EntryCompletion.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryCompletion.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EntryCompletion.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryCompletion.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EntryCompletion.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EntryCompletion.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Atk.Object.SignalSignatures {
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EntryIconAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<EntryIconAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof EntryIconAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryIconAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EntryIconAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EntryIconAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EntryIconAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EntryIconAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::above-child': (pspec: GObject.ParamSpec) => void;
            'notify::visible-window': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EventBox.SignalSignatures;

        // Fields

        bin: Bin;

        // Constructors

        constructor(properties?: Partial<EventBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): EventBox;

        // Signals

        connect<K extends keyof EventBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EventBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EventBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EventBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EventController.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<EventController.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof EventController.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventController.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EventController.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventController.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EventController.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EventController.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends EventController.SignalSignatures {
            'focus-in': () => void;
            'focus-out': () => void;
            'im-update': () => void;
            'key-pressed': (arg0: number, arg1: number, arg2: Gdk.ModifierType) => boolean | void;
            'key-released': (arg0: number, arg1: number, arg2: Gdk.ModifierType) => void;
            modifiers: (arg0: Gdk.ModifierType) => boolean | void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EventControllerKey.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<EventControllerKey.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): EventControllerKey;

        // Signals

        connect<K extends keyof EventControllerKey.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventControllerKey.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EventControllerKey.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventControllerKey.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EventControllerKey.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EventControllerKey.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends EventController.SignalSignatures {
            enter: (arg0: number, arg1: number) => void;
            leave: () => void;
            motion: (arg0: number, arg1: number) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EventControllerMotion.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<EventControllerMotion.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): EventControllerMotion;

        // Signals

        connect<K extends keyof EventControllerMotion.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventControllerMotion.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EventControllerMotion.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventControllerMotion.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EventControllerMotion.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EventControllerMotion.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): void;
    }

    namespace EventControllerScroll {
        // Signal signatures
        interface SignalSignatures extends EventController.SignalSignatures {
            decelerate: (arg0: number, arg1: number) => void;
            scroll: (arg0: number, arg1: number) => void;
            'scroll-begin': () => void;
            'scroll-end': () => void;
            'notify::flags': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: EventControllerScroll.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<EventControllerScroll.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget, flags: EventControllerScrollFlags): EventControllerScroll;

        // Signals

        connect<K extends keyof EventControllerScroll.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventControllerScroll.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof EventControllerScroll.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, EventControllerScroll.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof EventControllerScroll.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<EventControllerScroll.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            activate: () => void;
            'notify::expanded': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-fill': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::resize-toplevel': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::use-markup': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Expander.SignalSignatures;

        // 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<K extends keyof Expander.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Expander.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Expander.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Expander.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Expander.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Expander.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ExpanderAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ExpanderAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ExpanderAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ExpanderAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ExpanderAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ExpanderAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ExpanderAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ExpanderAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'file-set': () => void;
            'notify::dialog': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action': (pspec: GObject.ParamSpec) => void;
            'notify::create-folders': (pspec: GObject.ParamSpec) => void;
            'notify::do-overwrite-confirmation': (pspec: GObject.ParamSpec) => void;
            'notify::extra-widget': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget-active': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-hidden': (pspec: GObject.ParamSpec) => void;
            'notify::use-preview-label': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FileChooserButton.SignalSignatures;

        // 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<K extends keyof FileChooserButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FileChooserButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FileChooserButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FileChooserButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action': (pspec: GObject.ParamSpec) => void;
            'notify::create-folders': (pspec: GObject.ParamSpec) => void;
            'notify::do-overwrite-confirmation': (pspec: GObject.ParamSpec) => void;
            'notify::extra-widget': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget-active': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-hidden': (pspec: GObject.ParamSpec) => void;
            'notify::use-preview-label': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FileChooserDialog.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FileChooserDialog.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof FileChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FileChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FileChooserDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FileChooserDialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends NativeDialog.SignalSignatures {
            'notify::accept-label': (pspec: GObject.ParamSpec) => void;
            'notify::cancel-label': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::action': (pspec: GObject.ParamSpec) => void;
            'notify::create-folders': (pspec: GObject.ParamSpec) => void;
            'notify::do-overwrite-confirmation': (pspec: GObject.ParamSpec) => void;
            'notify::extra-widget': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget-active': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-hidden': (pspec: GObject.ParamSpec) => void;
            'notify::use-preview-label': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FileChooserNative.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof FileChooserNative.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserNative.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FileChooserNative.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserNative.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FileChooserNative.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FileChooserNative.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'desktop-folder': () => void;
            'down-folder': () => void;
            'home-folder': () => void;
            'location-popup': (arg0: string) => void;
            'location-popup-on-paste': () => void;
            'location-toggle-popup': () => void;
            'places-shortcut': () => void;
            'quick-bookmark': (arg0: number) => void;
            'recent-shortcut': () => void;
            'search-shortcut': () => void;
            'show-hidden': () => void;
            'up-folder': () => void;
            'notify::search-mode': (pspec: GObject.ParamSpec) => void;
            'notify::subtitle': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action': (pspec: GObject.ParamSpec) => void;
            'notify::create-folders': (pspec: GObject.ParamSpec) => void;
            'notify::do-overwrite-confirmation': (pspec: GObject.ParamSpec) => void;
            'notify::extra-widget': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget': (pspec: GObject.ParamSpec) => void;
            'notify::preview-widget-active': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-hidden': (pspec: GObject.ParamSpec) => void;
            'notify::use-preview-label': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FileChooserWidget.SignalSignatures;

        // 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<K extends keyof FileChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserWidget.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FileChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserWidget.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FileChooserWidget.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FileChooserWidget.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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);
        /**
         * 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FileChooserWidgetAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FileChooserWidgetAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof FileChooserWidgetAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserWidgetAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FileChooserWidgetAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileChooserWidgetAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FileChooserWidgetAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FileChooserWidgetAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends GObject.InitiallyUnowned.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FileFilter.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FileFilter.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): FileFilter;

        static new_from_gvariant(variant: GLib.Variant): FileFilter;

        // Signals

        connect<K extends keyof FileFilter.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileFilter.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FileFilter.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FileFilter.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FileFilter.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FileFilter.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Fixed.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Fixed.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Fixed;

        // Signals

        connect<K extends keyof Fixed.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Fixed.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Fixed.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Fixed.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Fixed.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Fixed.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'activate-cursor-child': () => void;
            'child-activated': (arg0: FlowBoxChild) => void;
            'move-cursor': (arg0: MovementStep, arg1: number) => boolean | void;
            'select-all': () => void;
            'selected-children-changed': () => void;
            'toggle-cursor-child': () => void;
            'unselect-all': () => void;
            'notify::activate-on-single-click': (pspec: GObject.ParamSpec) => void;
            'notify::column-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::max-children-per-line': (pspec: GObject.ParamSpec) => void;
            'notify::min-children-per-line': (pspec: GObject.ParamSpec) => void;
            'notify::row-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::selection-mode': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FlowBox.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<FlowBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): FlowBox;

        // Signals

        connect<K extends keyof FlowBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FlowBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FlowBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FlowBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FlowBoxAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FlowBoxAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof FlowBoxAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBoxAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FlowBoxAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBoxAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FlowBoxAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FlowBoxAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            activate: () => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FlowBoxChild.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FlowBoxChild.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): FlowBoxChild;

        // Signals

        connect<K extends keyof FlowBoxChild.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBoxChild.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FlowBoxChild.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBoxChild.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FlowBoxChild.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FlowBoxChild.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class FlowBoxChildAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<FlowBoxChildAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FlowBoxChildAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FlowBoxChildAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof FlowBoxChildAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBoxChildAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FlowBoxChildAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FlowBoxChildAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FlowBoxChildAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FlowBoxChildAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Button.SignalSignatures {
            'font-set': () => void;
            'notify::font-name': (pspec: GObject.ParamSpec) => void;
            'notify::show-size': (pspec: GObject.ParamSpec) => void;
            'notify::show-style': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::use-font': (pspec: GObject.ParamSpec) => void;
            'notify::use-size': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::font-features': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::level': (pspec: GObject.ParamSpec) => void;
            'notify::preview-text': (pspec: GObject.ParamSpec) => void;
            'notify::show-preview-entry': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FontButton.SignalSignatures;

        // 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<K extends keyof FontButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FontButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FontButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FontButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::font-features': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::level': (pspec: GObject.ParamSpec) => void;
            'notify::preview-text': (pspec: GObject.ParamSpec) => void;
            'notify::show-preview-entry': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FontChooserDialog.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof FontChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontChooserDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FontChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontChooserDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FontChooserDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FontChooserDialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::tweak-action': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::font-features': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::level': (pspec: GObject.ParamSpec) => void;
            'notify::preview-text': (pspec: GObject.ParamSpec) => void;
            'notify::show-preview-entry': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FontChooserWidget.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FontChooserWidget.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): FontChooserWidget;

        // Signals

        connect<K extends keyof FontChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontChooserWidget.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FontChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontChooserWidget.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FontChooserWidget.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FontChooserWidget.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::font-name': (pspec: GObject.ParamSpec) => void;
            'notify::preview-text': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FontSelection.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FontSelection.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): FontSelection;

        // Signals

        connect<K extends keyof FontSelection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontSelection.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FontSelection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontSelection.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FontSelection.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FontSelection.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FontSelectionDialog.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof FontSelectionDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontSelectionDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FontSelectionDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FontSelectionDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FontSelectionDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FontSelectionDialog.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::label-xalign': (pspec: GObject.ParamSpec) => void;
            'notify::label-yalign': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Frame.SignalSignatures;

        // Fields

        bin: Bin;

        // Constructors

        constructor(properties?: Partial<Frame.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](label?: string | null): Frame;

        // Signals

        connect<K extends keyof Frame.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Frame.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Frame.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Frame.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Frame.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Frame.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class FrameAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<FrameAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: FrameAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<FrameAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof FrameAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FrameAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof FrameAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, FrameAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof FrameAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<FrameAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'create-context': () => Gdk.GLContext;
            render: (arg0: Gdk.GLContext) => boolean | void;
            resize: (arg0: number, arg1: number) => void;
            'notify::auto-render': (pspec: GObject.ParamSpec) => void;
            'notify::context': (pspec: GObject.ParamSpec) => void;
            'notify::has-alpha': (pspec: GObject.ParamSpec) => void;
            'notify::has-depth-buffer': (pspec: GObject.ParamSpec) => void;
            'notify::has-stencil-buffer': (pspec: GObject.ParamSpec) => void;
            'notify::use-es': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GLArea.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GLArea.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): GLArea;

        // Signals

        connect<K extends keyof GLArea.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GLArea.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GLArea.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GLArea.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GLArea.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GLArea.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends EventController.SignalSignatures {
            begin: (arg0: Gdk.EventSequence | null) => void;
            cancel: (arg0: Gdk.EventSequence | null) => void;
            end: (arg0: Gdk.EventSequence | null) => void;
            'sequence-state-changed': (arg0: Gdk.EventSequence | null, arg1: EventSequenceState) => void;
            update: (arg0: Gdk.EventSequence | null) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Gesture.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Gesture.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Gesture.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Gesture.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Gesture.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Gesture.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Gesture.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Gesture.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GestureSingle.SignalSignatures {
            'drag-begin': (arg0: number, arg1: number) => void;
            'drag-end': (arg0: number, arg1: number) => void;
            'drag-update': (arg0: number, arg1: number) => void;
            'notify::button': (pspec: GObject.ParamSpec) => void;
            'notify::exclusive': (pspec: GObject.ParamSpec) => void;
            'notify::touch-only': (pspec: GObject.ParamSpec) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureDrag.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureDrag.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): GestureDrag;

        // Signals

        connect<K extends keyof GestureDrag.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureDrag.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureDrag.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureDrag.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureDrag.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureDrag.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GestureSingle.SignalSignatures {
            cancelled: () => void;
            pressed: (arg0: number, arg1: number) => void;
            'notify::delay-factor': (pspec: GObject.ParamSpec) => void;
            'notify::button': (pspec: GObject.ParamSpec) => void;
            'notify::exclusive': (pspec: GObject.ParamSpec) => void;
            'notify::touch-only': (pspec: GObject.ParamSpec) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureLongPress.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureLongPress.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): GestureLongPress;

        // Signals

        connect<K extends keyof GestureLongPress.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureLongPress.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureLongPress.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureLongPress.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureLongPress.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureLongPress.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;
    }

    namespace GestureMultiPress {
        // Signal signatures
        interface SignalSignatures extends GestureSingle.SignalSignatures {
            pressed: (arg0: number, arg1: number, arg2: number) => void;
            released: (arg0: number, arg1: number, arg2: number) => void;
            stopped: () => void;
            'notify::button': (pspec: GObject.ParamSpec) => void;
            'notify::exclusive': (pspec: GObject.ParamSpec) => void;
            'notify::touch-only': (pspec: GObject.ParamSpec) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureMultiPress.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureMultiPress.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): GestureMultiPress;

        // Signals

        connect<K extends keyof GestureMultiPress.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureMultiPress.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureMultiPress.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureMultiPress.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureMultiPress.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureMultiPress.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GestureDrag.SignalSignatures {
            pan: (arg0: PanDirection, arg1: number) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
            'notify::button': (pspec: GObject.ParamSpec) => void;
            'notify::exclusive': (pspec: GObject.ParamSpec) => void;
            'notify::touch-only': (pspec: GObject.ParamSpec) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GesturePan.SignalSignatures;

        // 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<K extends keyof GesturePan.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GesturePan.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GesturePan.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GesturePan.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GesturePan.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GesturePan.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Gesture.SignalSignatures {
            'angle-changed': (arg0: number, arg1: number) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureRotate.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureRotate.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): GestureRotate;

        // Signals

        connect<K extends keyof GestureRotate.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureRotate.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureRotate.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureRotate.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureRotate.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureRotate.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Gesture.SignalSignatures {
            'notify::button': (pspec: GObject.ParamSpec) => void;
            'notify::exclusive': (pspec: GObject.ParamSpec) => void;
            'notify::touch-only': (pspec: GObject.ParamSpec) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureSingle.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureSingle.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof GestureSingle.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureSingle.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureSingle.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureSingle.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureSingle.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureSingle.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GestureSingle.SignalSignatures {
            down: (arg0: number, arg1: number) => void;
            motion: (arg0: number, arg1: number) => void;
            proximity: (arg0: number, arg1: number) => void;
            up: (arg0: number, arg1: number) => void;
            'notify::button': (pspec: GObject.ParamSpec) => void;
            'notify::exclusive': (pspec: GObject.ParamSpec) => void;
            'notify::touch-only': (pspec: GObject.ParamSpec) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureStylus.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureStylus.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): GestureStylus;

        // Signals

        connect<K extends keyof GestureStylus.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureStylus.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureStylus.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureStylus.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureStylus.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureStylus.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GestureSingle.SignalSignatures {
            swipe: (arg0: number, arg1: number) => void;
            'notify::button': (pspec: GObject.ParamSpec) => void;
            'notify::exclusive': (pspec: GObject.ParamSpec) => void;
            'notify::touch-only': (pspec: GObject.ParamSpec) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureSwipe.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureSwipe.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): GestureSwipe;

        // Signals

        connect<K extends keyof GestureSwipe.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureSwipe.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureSwipe.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureSwipe.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureSwipe.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureSwipe.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Gesture.SignalSignatures {
            'scale-changed': (arg0: number) => void;
            'notify::n-points': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: GestureZoom.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<GestureZoom.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](widget: Widget): GestureZoom;

        // Signals

        connect<K extends keyof GestureZoom.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureZoom.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof GestureZoom.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, GestureZoom.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof GestureZoom.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<GestureZoom.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::baseline-row': (pspec: GObject.ParamSpec) => void;
            'notify::column-homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::column-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::row-homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::row-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Grid.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Grid.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Grid;

        // Signals

        connect<K extends keyof Grid.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Grid.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Grid.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Grid.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Grid.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Grid.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HBox.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof HBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 HButtonBox {
        // Signal signatures
        interface SignalSignatures extends ButtonBox.SignalSignatures {
            'notify::layout-style': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HButtonBox.SignalSignatures;

        // Fields

        button_box: ButtonBox;

        // Constructors

        constructor(properties?: Partial<HButtonBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): HButtonBox;

        // Signals

        connect<K extends keyof HButtonBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HButtonBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HButtonBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HButtonBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HButtonBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HButtonBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 HPaned {
        // Signal signatures
        interface SignalSignatures extends Paned.SignalSignatures {
            'notify::max-position': (pspec: GObject.ParamSpec) => void;
            'notify::min-position': (pspec: GObject.ParamSpec) => void;
            'notify::position': (pspec: GObject.ParamSpec) => void;
            'notify::position-set': (pspec: GObject.ParamSpec) => void;
            'notify::wide-handle': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HPaned.SignalSignatures;

        // Fields

        paned: Paned;

        // Constructors

        constructor(properties?: Partial<HPaned.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): HPaned;

        // Signals

        connect<K extends keyof HPaned.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HPaned.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HPaned.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HPaned.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HPaned.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HPaned.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 HSV {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            changed: () => void;
            move: (arg0: DirectionType) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HSV.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<HSV.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): HSV;

        // Signals

        connect<K extends keyof HSV.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HSV.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HSV.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HSV.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HSV.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HSV.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Scale.SignalSignatures {
            'notify::digits': (pspec: GObject.ParamSpec) => void;
            'notify::draw-value': (pspec: GObject.ParamSpec) => void;
            'notify::has-origin': (pspec: GObject.ParamSpec) => void;
            'notify::value-pos': (pspec: GObject.ParamSpec) => void;
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::lower-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::restrict-to-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::round-digits': (pspec: GObject.ParamSpec) => void;
            'notify::show-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::upper-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HScale.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof HScale.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HScale.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HScale.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HScale.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HScale.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HScale.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 HScrollbar {
        // Signal signatures
        interface SignalSignatures extends Scrollbar.SignalSignatures {
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::lower-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::restrict-to-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::round-digits': (pspec: GObject.ParamSpec) => void;
            'notify::show-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::upper-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HScrollbar.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof HScrollbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HScrollbar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HScrollbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HScrollbar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HScrollbar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HScrollbar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 HSeparator {
        // Signal signatures
        interface SignalSignatures extends Separator.SignalSignatures {
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HSeparator.SignalSignatures;

        // Fields

        separator: Separator;

        // Constructors

        constructor(properties?: Partial<HSeparator.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): HSeparator;

        // Signals

        connect<K extends keyof HSeparator.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HSeparator.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HSeparator.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HSeparator.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HSeparator.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HSeparator.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 HandleBox {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'child-attached': (arg0: Widget) => void;
            'child-detached': (arg0: Widget) => void;
            'notify::child-detached': (pspec: GObject.ParamSpec) => void;
            'notify::handle-position': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::snap-edge': (pspec: GObject.ParamSpec) => void;
            'notify::snap-edge-set': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HandleBox.SignalSignatures;

        // Fields

        bin: Bin;

        // Constructors

        constructor(properties?: Partial<HandleBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): HandleBox;

        // Signals

        connect<K extends keyof HandleBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HandleBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HandleBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HandleBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HandleBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HandleBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::custom-title': (pspec: GObject.ParamSpec) => void;
            'notify::decoration-layout': (pspec: GObject.ParamSpec) => void;
            'notify::decoration-layout-set': (pspec: GObject.ParamSpec) => void;
            'notify::has-subtitle': (pspec: GObject.ParamSpec) => void;
            'notify::show-close-button': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::subtitle': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HeaderBar.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<HeaderBar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): HeaderBar;

        // Signals

        connect<K extends keyof HeaderBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HeaderBar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HeaderBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HeaderBar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HeaderBar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HeaderBar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class HeaderBarAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<HeaderBarAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: HeaderBarAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<HeaderBarAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof HeaderBarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HeaderBarAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof HeaderBarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, HeaderBarAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof HeaderBarAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<HeaderBarAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            commit: (arg0: string) => void;
            'delete-surrounding': (arg0: number, arg1: number) => boolean | void;
            'preedit-changed': () => void;
            'preedit-end': () => void;
            'preedit-start': () => void;
            'retrieve-surrounding': () => boolean | void;
            'notify::input-hints': (pspec: GObject.ParamSpec) => void;
            'notify::input-purpose': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IMContext.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<IMContext.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof IMContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IMContext.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IMContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IMContext.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IMContext.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IMContext.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends IMContext.SignalSignatures {
            'notify::input-hints': (pspec: GObject.ParamSpec) => void;
            'notify::input-purpose': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IMContextSimple.SignalSignatures;

        // Fields

        object: IMContext;

        // Constructors

        constructor(properties?: Partial<IMContextSimple.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): IMContextSimple;

        // Signals

        connect<K extends keyof IMContextSimple.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IMContextSimple.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IMContextSimple.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IMContextSimple.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IMContextSimple.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IMContextSimple.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends IMContext.SignalSignatures {
            'notify::input-hints': (pspec: GObject.ParamSpec) => void;
            'notify::input-purpose': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends IMContext.ConstructorProps {}
    }

    class IMMulticontext extends IMContext {
        static $gtype: GObject.GType<IMMulticontext>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IMMulticontext.SignalSignatures;

        // Fields

        object: IMContext;

        // Constructors

        constructor(properties?: Partial<IMMulticontext.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): IMMulticontext;

        // Signals

        connect<K extends keyof IMMulticontext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IMMulticontext.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IMMulticontext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IMMulticontext.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IMMulticontext.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IMMulticontext.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IconFactory.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<IconFactory.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): IconFactory;

        // Signals

        connect<K extends keyof IconFactory.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconFactory.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IconFactory.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconFactory.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IconFactory.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IconFactory.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IconInfo.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<IconInfo.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static new_for_pixbuf(icon_theme: IconTheme, pixbuf: GdkPixbuf.Pixbuf): IconInfo;

        // Signals

        connect<K extends keyof IconInfo.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconInfo.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IconInfo.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconInfo.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IconInfo.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IconInfo.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IconTheme.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<IconTheme.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): IconTheme;

        // Signals

        connect<K extends keyof IconTheme.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconTheme.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IconTheme.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconTheme.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IconTheme.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IconTheme.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'activate-cursor-item': () => boolean | void;
            'item-activated': (arg0: TreePath) => void;
            'move-cursor': (arg0: MovementStep, arg1: number) => boolean | void;
            'select-all': () => void;
            'select-cursor-item': () => void;
            'selection-changed': () => void;
            'toggle-cursor-item': () => void;
            'unselect-all': () => void;
            'notify::activate-on-single-click': (pspec: GObject.ParamSpec) => void;
            'notify::cell-area': (pspec: GObject.ParamSpec) => void;
            'notify::column-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::columns': (pspec: GObject.ParamSpec) => void;
            'notify::item-orientation': (pspec: GObject.ParamSpec) => void;
            'notify::item-padding': (pspec: GObject.ParamSpec) => void;
            'notify::item-width': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::markup-column': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::pixbuf-column': (pspec: GObject.ParamSpec) => void;
            'notify::reorderable': (pspec: GObject.ParamSpec) => void;
            'notify::row-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::selection-mode': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::text-column': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-column': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscroll-policy': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscroll-policy': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IconView.SignalSignatures;

        // 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<K extends keyof IconView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconView.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IconView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconView.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IconView.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IconView.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: IconViewAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<IconViewAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof IconViewAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconViewAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof IconViewAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, IconViewAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof IconViewAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<IconViewAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Misc.SignalSignatures {
            'notify::file': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::icon-set': (pspec: GObject.ParamSpec) => void;
            'notify::icon-size': (pspec: GObject.ParamSpec) => void;
            'notify::pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::pixbuf-animation': (pspec: GObject.ParamSpec) => void;
            'notify::pixel-size': (pspec: GObject.ParamSpec) => void;
            'notify::resource': (pspec: GObject.ParamSpec) => void;
            'notify::stock': (pspec: GObject.ParamSpec) => void;
            'notify::storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::surface': (pspec: GObject.ParamSpec) => void;
            'notify::use-fallback': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Image.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof Image.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Image.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Image.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Image.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Image.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Image.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ImageAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ImageAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ImageAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ImageAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ImageAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ImageAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ImageAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ImageAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends RendererCellAccessible.SignalSignatures {
            'notify::renderer': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ImageCellAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ImageCellAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ImageCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ImageCellAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ImageCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ImageCellAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ImageCellAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ImageCellAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends MenuItem.SignalSignatures {
            'notify::accel-group': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::right-justified': (pspec: GObject.ParamSpec) => void;
            'notify::submenu': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ImageMenuItem.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof ImageMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ImageMenuItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ImageMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ImageMenuItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ImageMenuItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ImageMenuItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Box.SignalSignatures {
            close: () => void;
            response: (arg0: number) => void;
            'notify::message-type': (pspec: GObject.ParamSpec) => void;
            'notify::revealed': (pspec: GObject.ParamSpec) => void;
            'notify::show-close-button': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: InfoBar.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<InfoBar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): InfoBar;

        // Signals

        connect<K extends keyof InfoBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, InfoBar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof InfoBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, InfoBar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof InfoBar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<InfoBar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Invisible.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof Invisible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Invisible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Invisible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Invisible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Invisible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Invisible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Misc.SignalSignatures {
            'activate-current-link': () => void;
            'activate-link': (arg0: string) => boolean | void;
            'copy-clipboard': () => void;
            'move-cursor': (arg0: MovementStep, arg1: number, arg2: boolean) => void;
            'populate-popup': (arg0: Menu) => void;
            'notify::angle': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::cursor-position': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::justify': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::lines': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonic-keyval': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonic-widget': (pspec: GObject.ParamSpec) => void;
            'notify::pattern': (pspec: GObject.ParamSpec) => void;
            'notify::selectable': (pspec: GObject.ParamSpec) => void;
            'notify::selection-bound': (pspec: GObject.ParamSpec) => void;
            'notify::single-line-mode': (pspec: GObject.ParamSpec) => void;
            'notify::track-visited-links': (pspec: GObject.ParamSpec) => void;
            'notify::use-markup': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::wrap': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Label.SignalSignatures;

        // 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<K extends keyof Label.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Label.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Label.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Label.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Label.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Label.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: LabelAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<LabelAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof LabelAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LabelAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof LabelAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LabelAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof LabelAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<LabelAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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): string;
        /**
         * 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): string;
        /**
         * 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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscroll-policy': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscroll-policy': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Layout.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Layout.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](hadjustment?: Adjustment | null, vadjustment?: Adjustment | null): Layout;

        // Signals

        connect<K extends keyof Layout.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Layout.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Layout.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Layout.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Layout.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Layout.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'offset-changed': (arg0: string) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::max-value': (pspec: GObject.ParamSpec) => void;
            'notify::min-value': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
            'notify::value': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
            'offset-changed::inverted': (arg0: string) => void;
            'offset-changed::max-value': (arg0: string) => void;
            'offset-changed::min-value': (arg0: string) => void;
            'offset-changed::mode': (arg0: string) => void;
            'offset-changed::value': (arg0: string) => void;
            'offset-changed::app-paintable': (arg0: string) => void;
            'offset-changed::can-default': (arg0: string) => void;
            'offset-changed::can-focus': (arg0: string) => void;
            'offset-changed::composite-child': (arg0: string) => void;
            'offset-changed::double-buffered': (arg0: string) => void;
            'offset-changed::events': (arg0: string) => void;
            'offset-changed::expand': (arg0: string) => void;
            'offset-changed::focus-on-click': (arg0: string) => void;
            'offset-changed::halign': (arg0: string) => void;
            'offset-changed::has-default': (arg0: string) => void;
            'offset-changed::has-focus': (arg0: string) => void;
            'offset-changed::has-tooltip': (arg0: string) => void;
            'offset-changed::height-request': (arg0: string) => void;
            'offset-changed::hexpand': (arg0: string) => void;
            'offset-changed::hexpand-set': (arg0: string) => void;
            'offset-changed::is-focus': (arg0: string) => void;
            'offset-changed::margin': (arg0: string) => void;
            'offset-changed::margin-bottom': (arg0: string) => void;
            'offset-changed::margin-end': (arg0: string) => void;
            'offset-changed::margin-left': (arg0: string) => void;
            'offset-changed::margin-right': (arg0: string) => void;
            'offset-changed::margin-start': (arg0: string) => void;
            'offset-changed::margin-top': (arg0: string) => void;
            'offset-changed::name': (arg0: string) => void;
            'offset-changed::no-show-all': (arg0: string) => void;
            'offset-changed::opacity': (arg0: string) => void;
            'offset-changed::parent': (arg0: string) => void;
            'offset-changed::receives-default': (arg0: string) => void;
            'offset-changed::scale-factor': (arg0: string) => void;
            'offset-changed::sensitive': (arg0: string) => void;
            'offset-changed::style': (arg0: string) => void;
            'offset-changed::tooltip-markup': (arg0: string) => void;
            'offset-changed::tooltip-text': (arg0: string) => void;
            'offset-changed::valign': (arg0: string) => void;
            'offset-changed::vexpand': (arg0: string) => void;
            'offset-changed::vexpand-set': (arg0: string) => void;
            'offset-changed::visible': (arg0: string) => void;
            'offset-changed::width-request': (arg0: string) => void;
            'offset-changed::window': (arg0: string) => void;
            'offset-changed::orientation': (arg0: 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: LevelBar.SignalSignatures;

        // 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<K extends keyof LevelBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LevelBar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof LevelBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LevelBar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof LevelBar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<LevelBar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: LevelBarAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<LevelBarAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof LevelBarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LevelBarAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof LevelBarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LevelBarAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof LevelBarAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<LevelBarAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Button.SignalSignatures {
            'activate-link': () => boolean | void;
            'notify::uri': (pspec: GObject.ParamSpec) => void;
            'notify::visited': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: LinkButton.SignalSignatures;

        // 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<K extends keyof LinkButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LinkButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof LinkButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LinkButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof LinkButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<LinkButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ButtonAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: LinkButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<LinkButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof LinkButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LinkButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof LinkButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LinkButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof LinkButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<LinkButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'activate-cursor-row': () => void;
            'move-cursor': (arg0: MovementStep, arg1: number) => void;
            'row-activated': (arg0: ListBoxRow) => void;
            'row-selected': (arg0: ListBoxRow | null) => void;
            'select-all': () => void;
            'selected-rows-changed': () => void;
            'toggle-cursor-row': () => void;
            'unselect-all': () => void;
            'notify::activate-on-single-click': (pspec: GObject.ParamSpec) => void;
            'notify::selection-mode': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ListBox.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ListBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ListBox;

        // Signals

        connect<K extends keyof ListBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ListBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ListBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ListBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ListBoxAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ListBoxAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ListBoxAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBoxAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ListBoxAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBoxAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ListBoxAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ListBoxAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            activate: () => void;
            'notify::activatable': (pspec: GObject.ParamSpec) => void;
            'notify::selectable': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ListBoxRow.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ListBoxRow.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ListBoxRow;

        // Signals

        connect<K extends keyof ListBoxRow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBoxRow.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ListBoxRow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBoxRow.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ListBoxRow.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ListBoxRow.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class ListBoxRowAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<ListBoxRowAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ListBoxRowAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ListBoxRowAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ListBoxRowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBoxRowAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ListBoxRowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListBoxRowAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ListBoxRowAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ListBoxRowAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ListStore.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ListStore.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](types: GObject.GType[]): ListStore;

        // Signals

        connect<K extends keyof ListStore.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListStore.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ListStore.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ListStore.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ListStore.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ListStore.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Button.SignalSignatures {
            'notify::permission': (pspec: GObject.ParamSpec) => void;
            'notify::text-lock': (pspec: GObject.ParamSpec) => void;
            'notify::text-unlock': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-lock': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-not-authorized': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-unlock': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: LockButton.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof LockButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LockButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof LockButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LockButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof LockButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<LockButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ButtonAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: LockButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<LockButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof LockButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LockButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof LockButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, LockButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof LockButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<LockButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends MenuShell.SignalSignatures {
            'move-scroll': (arg0: ScrollType) => void;
            'popped-up': (arg0: any | null, arg1: any | null, arg2: boolean, arg3: boolean) => void;
            'notify::accel-group': (pspec: GObject.ParamSpec) => void;
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::anchor-hints': (pspec: GObject.ParamSpec) => void;
            'notify::attach-widget': (pspec: GObject.ParamSpec) => void;
            'notify::menu-type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::monitor': (pspec: GObject.ParamSpec) => void;
            'notify::rect-anchor-dx': (pspec: GObject.ParamSpec) => void;
            'notify::rect-anchor-dy': (pspec: GObject.ParamSpec) => void;
            'notify::reserve-toggle-size': (pspec: GObject.ParamSpec) => void;
            'notify::tearoff-state': (pspec: GObject.ParamSpec) => void;
            'notify::tearoff-title': (pspec: GObject.ParamSpec) => void;
            'notify::take-focus': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Menu.SignalSignatures;

        // 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<K extends keyof Menu.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Menu.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Menu.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Menu.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Menu.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Menu.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends MenuShellAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<MenuAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof MenuAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends MenuShell.SignalSignatures {
            'notify::child-pack-direction': (pspec: GObject.ParamSpec) => void;
            'notify::pack-direction': (pspec: GObject.ParamSpec) => void;
            'notify::take-focus': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuBar.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof MenuBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuBar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuBar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuBar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuBar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ToggleButton.SignalSignatures {
            'notify::align-widget': (pspec: GObject.ParamSpec) => void;
            'notify::direction': (pspec: GObject.ParamSpec) => void;
            'notify::menu-model': (pspec: GObject.ParamSpec) => void;
            'notify::popover': (pspec: GObject.ParamSpec) => void;
            'notify::popup': (pspec: GObject.ParamSpec) => void;
            'notify::use-popover': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-indicator': (pspec: GObject.ParamSpec) => void;
            'notify::inconsistent': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuButton.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<MenuButton.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): MenuButton;

        // Signals

        connect<K extends keyof MenuButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ToggleButtonAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<MenuButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof MenuButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            activate: () => void;
            'activate-item': () => void;
            deselect: () => void;
            select: () => void;
            'toggle-size-allocate': (arg0: number) => void;
            'toggle-size-request': (arg0: any | null) => void;
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::right-justified': (pspec: GObject.ParamSpec) => void;
            'notify::submenu': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuItem.SignalSignatures;

        // 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<K extends keyof MenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuItemAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<MenuItemAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof MenuItemAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuItemAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuItemAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuItemAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuItemAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuItemAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'activate-current': (arg0: boolean) => void;
            cancel: () => void;
            'cycle-focus': (arg0: DirectionType) => void;
            deactivate: () => void;
            insert: (arg0: Widget, arg1: number) => void;
            'move-current': (arg0: MenuDirectionType) => void;
            'move-selected': (arg0: number) => boolean | void;
            'selection-done': () => void;
            'notify::take-focus': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuShell.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<MenuShell.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof MenuShell.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuShell.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuShell.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuShell.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuShell.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuShell.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuShellAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<MenuShellAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof MenuShellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuShellAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuShellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuShellAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuShellAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuShellAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends ToolButton.SignalSignatures {
            'show-menu': () => void;
            'notify::menu': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::icon-widget': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MenuToolButton.SignalSignatures;

        // 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<K extends keyof MenuToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuToolButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MenuToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MenuToolButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MenuToolButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MenuToolButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::buttons': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::message-area': (pspec: GObject.ParamSpec) => void;
            'notify::message-type': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-text': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-use-markup': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::use-markup': (pspec: GObject.ParamSpec) => void;
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MessageDialog.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<MessageDialog.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof MessageDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MessageDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MessageDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MessageDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MessageDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MessageDialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::xpad': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::ypad': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Misc.SignalSignatures;

        // Fields

        widget: Widget;

        // Constructors

        constructor(properties?: Partial<Misc.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Misc.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Misc.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Misc.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Misc.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Misc.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Misc.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Button.SignalSignatures {
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::centered': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::iconic': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::menu-name': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::use-markup': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ModelButton.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ModelButton.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ModelButton;

        // Signals

        connect<K extends keyof ModelButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ModelButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ModelButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ModelButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ModelButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ModelButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 MountOperation {
        // Signal signatures
        interface SignalSignatures extends Gio.MountOperation.SignalSignatures {
            'notify::is-showing': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::anonymous': (pspec: GObject.ParamSpec) => void;
            'notify::choice': (pspec: GObject.ParamSpec) => void;
            'notify::domain': (pspec: GObject.ParamSpec) => void;
            'notify::is-tcrypt-hidden-volume': (pspec: GObject.ParamSpec) => void;
            'notify::is-tcrypt-system-volume': (pspec: GObject.ParamSpec) => void;
            'notify::password': (pspec: GObject.ParamSpec) => void;
            'notify::password-save': (pspec: GObject.ParamSpec) => void;
            'notify::pim': (pspec: GObject.ParamSpec) => void;
            'notify::username': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: MountOperation.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof MountOperation.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MountOperation.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof MountOperation.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, MountOperation.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof MountOperation.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<MountOperation.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            response: (arg0: number) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: NativeDialog.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<NativeDialog.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof NativeDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NativeDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof NativeDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NativeDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof NativeDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<NativeDialog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'change-current-page': (arg0: number) => boolean | void;
            'create-window': (arg0: Widget, arg1: number, arg2: number) => Notebook;
            'focus-tab': (arg0: NotebookTab) => boolean | void;
            'move-focus-out': (arg0: DirectionType) => void;
            'page-added': (arg0: Widget, arg1: number) => void;
            'page-removed': (arg0: Widget, arg1: number) => void;
            'page-reordered': (arg0: Widget, arg1: number) => void;
            'reorder-tab': (arg0: DirectionType, arg1: boolean) => boolean | void;
            'select-page': (arg0: boolean) => boolean | void;
            'switch-page': (arg0: Widget, arg1: number) => void;
            'notify::enable-popup': (pspec: GObject.ParamSpec) => void;
            'notify::group-name': (pspec: GObject.ParamSpec) => void;
            'notify::page': (pspec: GObject.ParamSpec) => void;
            'notify::scrollable': (pspec: GObject.ParamSpec) => void;
            'notify::show-border': (pspec: GObject.ParamSpec) => void;
            'notify::show-tabs': (pspec: GObject.ParamSpec) => void;
            'notify::tab-pos': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Notebook.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Notebook.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Notebook;

        // Signals

        connect<K extends keyof Notebook.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Notebook.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Notebook.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Notebook.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Notebook.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Notebook.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: NotebookAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<NotebookAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof NotebookAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NotebookAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof NotebookAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NotebookAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof NotebookAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<NotebookAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Atk.Object.SignalSignatures {
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: NotebookPageAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<NotebookPageAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](notebook: NotebookAccessible, child: Widget): NotebookPageAccessible;

        // Signals

        connect<K extends keyof NotebookPageAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NotebookPageAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof NotebookPageAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NotebookPageAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof NotebookPageAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<NotebookPageAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Gio.EmblemedIcon.SignalSignatures {
            'notify::background-icon': (pspec: GObject.ParamSpec) => void;
            'notify::background-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::count': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::style-context': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: NumerableIcon.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<NumerableIcon.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof NumerableIcon.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NumerableIcon.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof NumerableIcon.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, NumerableIcon.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof NumerableIcon.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<NumerableIcon.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Window.SignalSignatures {
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: OffscreenWindow.SignalSignatures;

        // Fields

        parent_object: Window;

        // Constructors

        constructor(properties?: Partial<OffscreenWindow.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): OffscreenWindow;

        // Signals

        connect<K extends keyof OffscreenWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, OffscreenWindow.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof OffscreenWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, OffscreenWindow.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof OffscreenWindow.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<OffscreenWindow.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'get-child-position': (arg0: Widget, arg1: Gdk.Rectangle) => boolean | void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Overlay.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Overlay.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Overlay;

        // Signals

        connect<K extends keyof Overlay.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Overlay.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Overlay.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Overlay.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Overlay.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Overlay.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends EventController.SignalSignatures {
            'notify::action-group': (pspec: GObject.ParamSpec) => void;
            'notify::pad': (pspec: GObject.ParamSpec) => void;
            'notify::propagation-phase': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PadController.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PadController.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](window: Window, group: Gio.ActionGroup, pad?: Gdk.Device | null): PadController;

        // Signals

        connect<K extends keyof PadController.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PadController.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PadController.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PadController.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PadController.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PadController.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PageSetup.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof PageSetup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PageSetup.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PageSetup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PageSetup.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PageSetup.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PageSetup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'accept-position': () => boolean | void;
            'cancel-position': () => boolean | void;
            'cycle-child-focus': (arg0: boolean) => boolean | void;
            'cycle-handle-focus': (arg0: boolean) => boolean | void;
            'move-handle': (arg0: ScrollType) => boolean | void;
            'toggle-handle-focus': () => boolean | void;
            'notify::max-position': (pspec: GObject.ParamSpec) => void;
            'notify::min-position': (pspec: GObject.ParamSpec) => void;
            'notify::position': (pspec: GObject.ParamSpec) => void;
            'notify::position-set': (pspec: GObject.ParamSpec) => void;
            'notify::wide-handle': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Paned.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Paned.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](orientation: Orientation): Paned;

        // Signals

        connect<K extends keyof Paned.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Paned.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Paned.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Paned.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Paned.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Paned.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PanedAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PanedAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof PanedAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PanedAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PanedAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PanedAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PanedAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PanedAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends ScrolledWindow.SignalSignatures {
            'drag-action-ask': (arg0: number) => number;
            'drag-action-requested': (arg0: Gdk.DragContext, arg1: Gio.File, arg2: Gio.File[]) => number;
            'drag-perform-drop': (arg0: Gio.File, arg1: Gio.File[], arg2: number) => void;
            mount: (arg0: Gio.MountOperation) => void;
            'open-location': (arg0: Gio.File, arg1: PlacesOpenFlags) => void;
            'populate-popup': (arg0: Widget, arg1: Gio.File | null, arg2: Gio.Volume | null) => void;
            'show-connect-to-server': () => void;
            'show-enter-location': () => void;
            'show-error-message': (arg0: string, arg1: string) => void;
            'show-other-locations': () => void;
            'show-other-locations-with-flags': (arg0: PlacesOpenFlags) => void;
            'show-starred-location': (arg0: PlacesOpenFlags) => void;
            unmount: (arg0: Gio.MountOperation) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::location': (pspec: GObject.ParamSpec) => void;
            'notify::open-flags': (pspec: GObject.ParamSpec) => void;
            'notify::populate-all': (pspec: GObject.ParamSpec) => void;
            'notify::show-connect-to-server': (pspec: GObject.ParamSpec) => void;
            'notify::show-desktop': (pspec: GObject.ParamSpec) => void;
            'notify::show-enter-location': (pspec: GObject.ParamSpec) => void;
            'notify::show-other-locations': (pspec: GObject.ParamSpec) => void;
            'notify::show-recent': (pspec: GObject.ParamSpec) => void;
            'notify::show-starred-location': (pspec: GObject.ParamSpec) => void;
            'notify::show-trash': (pspec: GObject.ParamSpec) => void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscrollbar-policy': (pspec: GObject.ParamSpec) => void;
            'notify::kinetic-scrolling': (pspec: GObject.ParamSpec) => void;
            'notify::max-content-height': (pspec: GObject.ParamSpec) => void;
            'notify::max-content-width': (pspec: GObject.ParamSpec) => void;
            'notify::min-content-height': (pspec: GObject.ParamSpec) => void;
            'notify::min-content-width': (pspec: GObject.ParamSpec) => void;
            'notify::overlay-scrolling': (pspec: GObject.ParamSpec) => void;
            'notify::propagate-natural-height': (pspec: GObject.ParamSpec) => void;
            'notify::propagate-natural-width': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscrollbar-policy': (pspec: GObject.ParamSpec) => void;
            'notify::window-placement': (pspec: GObject.ParamSpec) => void;
            'notify::window-placement-set': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PlacesSidebar.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PlacesSidebar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): PlacesSidebar;

        // Signals

        connect<K extends keyof PlacesSidebar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PlacesSidebar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PlacesSidebar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PlacesSidebar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PlacesSidebar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PlacesSidebar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Window.SignalSignatures {
            embedded: () => void;
            'notify::embedded': (pspec: GObject.ParamSpec) => void;
            'notify::socket-window': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Plug.SignalSignatures;

        // 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<K extends keyof Plug.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Plug.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Plug.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Plug.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Plug.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Plug.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends WindowAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PlugAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PlugAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof PlugAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PlugAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PlugAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PlugAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PlugAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PlugAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            closed: () => void;
            'notify::constrain-to': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::pointing-to': (pspec: GObject.ParamSpec) => void;
            'notify::position': (pspec: GObject.ParamSpec) => void;
            'notify::relative-to': (pspec: GObject.ParamSpec) => void;
            'notify::transitions-enabled': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Popover.SignalSignatures;

        // 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<K extends keyof Popover.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Popover.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Popover.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Popover.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Popover.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Popover.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class PopoverAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<PopoverAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PopoverAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PopoverAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof PopoverAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PopoverAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PopoverAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PopoverAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PopoverAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PopoverAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Popover.SignalSignatures {
            'notify::visible-submenu': (pspec: GObject.ParamSpec) => void;
            'notify::constrain-to': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::pointing-to': (pspec: GObject.ParamSpec) => void;
            'notify::position': (pspec: GObject.ParamSpec) => void;
            'notify::relative-to': (pspec: GObject.ParamSpec) => void;
            'notify::transitions-enabled': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PopoverMenu.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PopoverMenu.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): PopoverMenu;

        // Signals

        connect<K extends keyof PopoverMenu.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PopoverMenu.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PopoverMenu.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PopoverMenu.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PopoverMenu.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PopoverMenu.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PrintContext.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PrintContext.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof PrintContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PrintContext.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PrintContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PrintContext.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PrintContext.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PrintContext.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'begin-print': (arg0: PrintContext) => void;
            'create-custom-widget': () => GObject.Object;
            'custom-widget-apply': (arg0: Widget) => void;
            done: (arg0: PrintOperationResult) => void;
            'draw-page': (arg0: PrintContext, arg1: number) => void;
            'end-print': (arg0: PrintContext) => void;
            paginate: (arg0: PrintContext) => boolean | void;
            preview: (arg0: PrintOperationPreview, arg1: PrintContext, arg2: Window | null) => boolean | void;
            'request-page-setup': (arg0: PrintContext, arg1: number, arg2: PageSetup) => void;
            'status-changed': () => void;
            'update-custom-widget': (arg0: Widget, arg1: PageSetup, arg2: PrintSettings) => void;
            'notify::allow-async': (pspec: GObject.ParamSpec) => void;
            'notify::current-page': (pspec: GObject.ParamSpec) => void;
            'notify::custom-tab-label': (pspec: GObject.ParamSpec) => void;
            'notify::default-page-setup': (pspec: GObject.ParamSpec) => void;
            'notify::embed-page-setup': (pspec: GObject.ParamSpec) => void;
            'notify::export-filename': (pspec: GObject.ParamSpec) => void;
            'notify::has-selection': (pspec: GObject.ParamSpec) => void;
            'notify::job-name': (pspec: GObject.ParamSpec) => void;
            'notify::n-pages': (pspec: GObject.ParamSpec) => void;
            'notify::n-pages-to-print': (pspec: GObject.ParamSpec) => void;
            'notify::print-settings': (pspec: GObject.ParamSpec) => void;
            'notify::show-progress': (pspec: GObject.ParamSpec) => void;
            'notify::status': (pspec: GObject.ParamSpec) => void;
            'notify::status-string': (pspec: GObject.ParamSpec) => void;
            'notify::support-selection': (pspec: GObject.ParamSpec) => void;
            'notify::track-print-status': (pspec: GObject.ParamSpec) => void;
            'notify::unit': (pspec: GObject.ParamSpec) => void;
            'notify::use-full-page': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PrintOperation.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<PrintOperation.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): PrintOperation;

        // Signals

        connect<K extends keyof PrintOperation.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PrintOperation.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PrintOperation.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PrintOperation.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PrintOperation.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PrintOperation.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: PrintSettings.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof PrintSettings.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PrintSettings.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof PrintSettings.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, PrintSettings.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof PrintSettings.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<PrintSettings.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::fraction': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::pulse-step': (pspec: GObject.ParamSpec) => void;
            'notify::show-text': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ProgressBar.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ProgressBar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ProgressBar;

        // Signals

        connect<K extends keyof ProgressBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ProgressBar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ProgressBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ProgressBar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ProgressBar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ProgressBar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ProgressBarAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ProgressBarAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ProgressBarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ProgressBarAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ProgressBarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ProgressBarAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ProgressBarAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ProgressBarAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends ToggleAction.SignalSignatures {
            changed: (arg0: RadioAction) => void;
            'notify::current-value': (pspec: GObject.ParamSpec) => void;
            'notify::group': (pspec: GObject.ParamSpec) => void;
            'notify::value': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-as-radio': (pspec: GObject.ParamSpec) => void;
            'notify::action-group': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
            'notify::hide-if-empty': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::short-label': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-overflown': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RadioAction.SignalSignatures;

        // 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<K extends keyof RadioAction.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioAction.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RadioAction.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioAction.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RadioAction.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RadioAction.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends CheckButton.SignalSignatures {
            'group-changed': () => void;
            'notify::group': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-indicator': (pspec: GObject.ParamSpec) => void;
            'notify::inconsistent': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RadioButton.SignalSignatures;

        // 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<K extends keyof RadioButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RadioButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RadioButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RadioButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ToggleButtonAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RadioButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RadioButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof RadioButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RadioButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RadioButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RadioButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends CheckMenuItem.SignalSignatures {
            'group-changed': () => void;
            'notify::group': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-as-radio': (pspec: GObject.ParamSpec) => void;
            'notify::inconsistent': (pspec: GObject.ParamSpec) => void;
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::right-justified': (pspec: GObject.ParamSpec) => void;
            'notify::submenu': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RadioMenuItem.SignalSignatures;

        // 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<K extends keyof RadioMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioMenuItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RadioMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioMenuItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RadioMenuItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RadioMenuItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends CheckMenuItemAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RadioMenuItemAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RadioMenuItemAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof RadioMenuItemAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioMenuItemAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RadioMenuItemAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioMenuItemAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RadioMenuItemAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RadioMenuItemAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends ToggleToolButton.SignalSignatures {
            'notify::group': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::icon-widget': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RadioToolButton.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof RadioToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioToolButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RadioToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RadioToolButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RadioToolButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RadioToolButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'adjust-bounds': (arg0: number) => void;
            'change-value': (arg0: ScrollType, arg1: number) => boolean | void;
            'move-slider': (arg0: ScrollType) => void;
            'value-changed': () => void;
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::lower-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::restrict-to-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::round-digits': (pspec: GObject.ParamSpec) => void;
            'notify::show-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::upper-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Range.SignalSignatures;

        // Fields

        widget: Widget;

        // Constructors

        constructor(properties?: Partial<Range.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Range.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Range.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Range.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Range.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Range.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Range.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RangeAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RangeAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof RangeAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RangeAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RangeAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RangeAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RangeAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RangeAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RcStyle.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof RcStyle.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RcStyle.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RcStyle.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RcStyle.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RcStyle.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RcStyle.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Action.SignalSignatures {
            'notify::show-numbers': (pspec: GObject.ParamSpec) => void;
            'notify::action-group': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
            'notify::hide-if-empty': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::short-label': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-overflown': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::limit': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::recent-manager': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-icons': (pspec: GObject.ParamSpec) => void;
            'notify::show-not-found': (pspec: GObject.ParamSpec) => void;
            'notify::show-private': (pspec: GObject.ParamSpec) => void;
            'notify::show-tips': (pspec: GObject.ParamSpec) => void;
            'notify::sort-type': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RecentAction.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof RecentAction.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentAction.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RecentAction.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentAction.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RecentAction.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RecentAction.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Dialog.SignalSignatures {
            'notify::use-header-bar': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::limit': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::recent-manager': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-icons': (pspec: GObject.ParamSpec) => void;
            'notify::show-not-found': (pspec: GObject.ParamSpec) => void;
            'notify::show-private': (pspec: GObject.ParamSpec) => void;
            'notify::show-tips': (pspec: GObject.ParamSpec) => void;
            'notify::sort-type': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RecentChooserDialog.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RecentChooserDialog.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof RecentChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentChooserDialog.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RecentChooserDialog.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentChooserDialog.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RecentChooserDialog.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RecentChooserDialog.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Menu.SignalSignatures {
            'notify::show-numbers': (pspec: GObject.ParamSpec) => void;
            'notify::accel-group': (pspec: GObject.ParamSpec) => void;
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::anchor-hints': (pspec: GObject.ParamSpec) => void;
            'notify::attach-widget': (pspec: GObject.ParamSpec) => void;
            'notify::menu-type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::monitor': (pspec: GObject.ParamSpec) => void;
            'notify::rect-anchor-dx': (pspec: GObject.ParamSpec) => void;
            'notify::rect-anchor-dy': (pspec: GObject.ParamSpec) => void;
            'notify::reserve-toggle-size': (pspec: GObject.ParamSpec) => void;
            'notify::tearoff-state': (pspec: GObject.ParamSpec) => void;
            'notify::tearoff-title': (pspec: GObject.ParamSpec) => void;
            'notify::take-focus': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::limit': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::recent-manager': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-icons': (pspec: GObject.ParamSpec) => void;
            'notify::show-not-found': (pspec: GObject.ParamSpec) => void;
            'notify::show-private': (pspec: GObject.ParamSpec) => void;
            'notify::show-tips': (pspec: GObject.ParamSpec) => void;
            'notify::sort-type': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RecentChooserMenu.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RecentChooserMenu.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): RecentChooserMenu;

        static new_for_manager(manager: RecentManager): RecentChooserMenu;

        // Signals

        connect<K extends keyof RecentChooserMenu.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentChooserMenu.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RecentChooserMenu.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentChooserMenu.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RecentChooserMenu.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RecentChooserMenu.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
            'notify::filter': (pspec: GObject.ParamSpec) => void;
            'notify::limit': (pspec: GObject.ParamSpec) => void;
            'notify::local-only': (pspec: GObject.ParamSpec) => void;
            'notify::recent-manager': (pspec: GObject.ParamSpec) => void;
            'notify::select-multiple': (pspec: GObject.ParamSpec) => void;
            'notify::show-icons': (pspec: GObject.ParamSpec) => void;
            'notify::show-not-found': (pspec: GObject.ParamSpec) => void;
            'notify::show-private': (pspec: GObject.ParamSpec) => void;
            'notify::show-tips': (pspec: GObject.ParamSpec) => void;
            'notify::sort-type': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RecentChooserWidget.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RecentChooserWidget.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): RecentChooserWidget;

        static new_for_manager(manager: RecentManager): RecentChooserWidget;

        // Signals

        connect<K extends keyof RecentChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentChooserWidget.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RecentChooserWidget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentChooserWidget.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RecentChooserWidget.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RecentChooserWidget.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.InitiallyUnowned.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RecentFilter.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RecentFilter.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): RecentFilter;

        // Signals

        connect<K extends keyof RecentFilter.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentFilter.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RecentFilter.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentFilter.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RecentFilter.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RecentFilter.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            changed: () => void;
            'notify::filename': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RecentManager.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RecentManager.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): RecentManager;

        // Signals

        connect<K extends keyof RecentManager.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentManager.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RecentManager.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RecentManager.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RecentManager.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RecentManager.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends CellAccessible.SignalSignatures {
            'notify::renderer': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: RendererCellAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<RendererCellAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](renderer: CellRenderer): RendererCellAccessible;

        // Signals

        connect<K extends keyof RendererCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RendererCellAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof RendererCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, RendererCellAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof RendererCellAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<RendererCellAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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
        /**
         * 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 {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::child-revealed': (pspec: GObject.ParamSpec) => void;
            'notify::reveal-child': (pspec: GObject.ParamSpec) => void;
            'notify::transition-duration': (pspec: GObject.ParamSpec) => void;
            'notify::transition-type': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Revealer.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Revealer.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Revealer;

        // Signals

        connect<K extends keyof Revealer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Revealer.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Revealer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Revealer.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Revealer.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Revealer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Range.SignalSignatures {
            'format-value': (arg0: number) => string;
            'notify::digits': (pspec: GObject.ParamSpec) => void;
            'notify::draw-value': (pspec: GObject.ParamSpec) => void;
            'notify::has-origin': (pspec: GObject.ParamSpec) => void;
            'notify::value-pos': (pspec: GObject.ParamSpec) => void;
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::lower-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::restrict-to-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::round-digits': (pspec: GObject.ParamSpec) => void;
            'notify::show-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::upper-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Scale.SignalSignatures;

        // 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<K extends keyof Scale.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Scale.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Scale.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Scale.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Scale.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Scale.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends RangeAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ScaleAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ScaleAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ScaleAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScaleAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ScaleAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScaleAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ScaleAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ScaleAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Button.SignalSignatures {
            popdown: () => void;
            popup: () => void;
            'value-changed': (arg0: number) => void;
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::icons': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::value': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ScaleButton.SignalSignatures;

        // 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<K extends keyof ScaleButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScaleButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ScaleButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScaleButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ScaleButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ScaleButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ButtonAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ScaleButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ScaleButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ScaleButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScaleButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ScaleButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScaleButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ScaleButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ScaleButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Range.SignalSignatures {
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::lower-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::restrict-to-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::round-digits': (pspec: GObject.ParamSpec) => void;
            'notify::show-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::upper-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Scrollbar.SignalSignatures;

        // Fields

        range: Range;

        // Constructors

        constructor(properties?: Partial<Scrollbar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](orientation: Orientation, adjustment?: Adjustment | null): Scrollbar;

        // Signals

        connect<K extends keyof Scrollbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Scrollbar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Scrollbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Scrollbar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Scrollbar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Scrollbar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 ScrolledWindow {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'edge-overshot': (arg0: PositionType) => void;
            'edge-reached': (arg0: PositionType) => void;
            'move-focus-out': (arg0: DirectionType) => void;
            'scroll-child': (arg0: ScrollType, arg1: boolean) => boolean | void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscrollbar-policy': (pspec: GObject.ParamSpec) => void;
            'notify::kinetic-scrolling': (pspec: GObject.ParamSpec) => void;
            'notify::max-content-height': (pspec: GObject.ParamSpec) => void;
            'notify::max-content-width': (pspec: GObject.ParamSpec) => void;
            'notify::min-content-height': (pspec: GObject.ParamSpec) => void;
            'notify::min-content-width': (pspec: GObject.ParamSpec) => void;
            'notify::overlay-scrolling': (pspec: GObject.ParamSpec) => void;
            'notify::propagate-natural-height': (pspec: GObject.ParamSpec) => void;
            'notify::propagate-natural-width': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscrollbar-policy': (pspec: GObject.ParamSpec) => void;
            'notify::window-placement': (pspec: GObject.ParamSpec) => void;
            'notify::window-placement-set': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ScrolledWindow.SignalSignatures;

        // 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<K extends keyof ScrolledWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScrolledWindow.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ScrolledWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScrolledWindow.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ScrolledWindow.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ScrolledWindow.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class ScrolledWindowAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<ScrolledWindowAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ScrolledWindowAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ScrolledWindowAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ScrolledWindowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScrolledWindowAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ScrolledWindowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ScrolledWindowAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ScrolledWindowAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ScrolledWindowAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::search-mode-enabled': (pspec: GObject.ParamSpec) => void;
            'notify::show-close-button': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SearchBar.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SearchBar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): SearchBar;

        // Signals

        connect<K extends keyof SearchBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SearchBar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SearchBar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SearchBar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SearchBar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SearchBar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Entry.SignalSignatures {
            'next-match': () => void;
            'previous-match': () => void;
            'search-changed': () => void;
            'stop-search': () => void;
            'notify::activates-default': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::buffer': (pspec: GObject.ParamSpec) => void;
            'notify::caps-lock-warning': (pspec: GObject.ParamSpec) => void;
            'notify::completion': (pspec: GObject.ParamSpec) => void;
            'notify::cursor-position': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::enable-emoji-completion': (pspec: GObject.ParamSpec) => void;
            'notify::has-frame': (pspec: GObject.ParamSpec) => void;
            'notify::im-module': (pspec: GObject.ParamSpec) => void;
            'notify::inner-border': (pspec: GObject.ParamSpec) => void;
            'notify::input-hints': (pspec: GObject.ParamSpec) => void;
            'notify::input-purpose': (pspec: GObject.ParamSpec) => void;
            'notify::invisible-char': (pspec: GObject.ParamSpec) => void;
            'notify::invisible-char-set': (pspec: GObject.ParamSpec) => void;
            'notify::max-length': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::overwrite-mode': (pspec: GObject.ParamSpec) => void;
            'notify::placeholder-text': (pspec: GObject.ParamSpec) => void;
            'notify::populate-all': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-activatable': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-gicon': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-stock': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::progress-fraction': (pspec: GObject.ParamSpec) => void;
            'notify::progress-pulse-step': (pspec: GObject.ParamSpec) => void;
            'notify::scroll-offset': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-activatable': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-gicon': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-stock': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::selection-bound': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::show-emoji-icon': (pspec: GObject.ParamSpec) => void;
            'notify::tabs': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::text-length': (pspec: GObject.ParamSpec) => void;
            'notify::truncate-multiline': (pspec: GObject.ParamSpec) => void;
            'notify::visibility': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::editing-canceled': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SearchEntry.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SearchEntry.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): SearchEntry;

        // Signals

        connect<K extends keyof SearchEntry.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SearchEntry.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SearchEntry.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SearchEntry.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SearchEntry.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SearchEntry.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Separator.SignalSignatures;

        // Fields

        widget: Widget;

        // Constructors

        constructor(properties?: Partial<Separator.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](orientation: Orientation): Separator;

        // Signals

        connect<K extends keyof Separator.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Separator.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Separator.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Separator.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Separator.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Separator.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 SeparatorMenuItem {
        // Signal signatures
        interface SignalSignatures extends MenuItem.SignalSignatures {
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::right-justified': (pspec: GObject.ParamSpec) => void;
            'notify::submenu': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SeparatorMenuItem.SignalSignatures;

        // Fields

        menu_item: MenuItem;

        // Constructors

        constructor(properties?: Partial<SeparatorMenuItem.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): SeparatorMenuItem;

        // Signals

        connect<K extends keyof SeparatorMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SeparatorMenuItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SeparatorMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SeparatorMenuItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SeparatorMenuItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SeparatorMenuItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 SeparatorToolItem {
        // Signal signatures
        interface SignalSignatures extends ToolItem.SignalSignatures {
            'notify::draw': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SeparatorToolItem.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SeparatorToolItem.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): SeparatorToolItem;

        // Signals

        connect<K extends keyof SeparatorToolItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SeparatorToolItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SeparatorToolItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SeparatorToolItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SeparatorToolItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SeparatorToolItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::color-hash': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-alternative-button-order': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-alternative-sort-arrows': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-application-prefer-dark-theme': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-auto-mnemonics': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-button-images': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-can-change-accels': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-color-palette': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-color-scheme': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-cursor-aspect-ratio': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-cursor-blink': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-cursor-blink-time': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-cursor-blink-timeout': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-cursor-theme-name': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-cursor-theme-size': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-decoration-layout': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-dialogs-use-header': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-dnd-drag-threshold': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-double-click-distance': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-double-click-time': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-enable-accels': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-enable-animations': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-enable-event-sounds': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-enable-input-feedback-sounds': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-enable-mnemonics': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-enable-primary-paste': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-enable-tooltips': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-entry-password-hint-timeout': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-entry-select-on-focus': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-error-bell': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-fallback-icon-theme': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-file-chooser-backend': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-font-name': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-fontconfig-timestamp': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-icon-sizes': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-icon-theme-name': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-im-module': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-im-preedit-style': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-im-status-style': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-key-theme-name': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-keynav-cursor-only': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-keynav-use-caret': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-keynav-wrap-around': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-label-select-on-focus': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-long-press-time': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-menu-bar-accel': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-menu-bar-popup-delay': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-menu-images': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-menu-popdown-delay': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-menu-popup-delay': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-modules': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-overlay-scrolling': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-primary-button-warps-slider': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-print-backends': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-print-preview-command': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-recent-files-enabled': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-recent-files-limit': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-recent-files-max-age': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-scrolled-window-placement': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-shell-shows-app-menu': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-shell-shows-desktop': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-shell-shows-menubar': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-show-input-method-menu': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-show-unicode-menu': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-sound-theme-name': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-split-cursor': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-theme-name': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-timeout-expand': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-timeout-initial': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-timeout-repeat': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-titlebar-double-click': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-titlebar-middle-click': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-titlebar-right-click': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-toolbar-icon-size': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-toolbar-style': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-tooltip-browse-mode-timeout': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-tooltip-browse-timeout': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-tooltip-timeout': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-touchscreen-mode': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-visible-focus': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-xft-antialias': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-xft-dpi': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-xft-hinting': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-xft-hintstyle': (pspec: GObject.ParamSpec) => void;
            'notify::gtk-xft-rgba': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Settings.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Settings.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Settings.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Settings.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Settings.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Settings.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Settings.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Settings.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::accelerator': (pspec: GObject.ParamSpec) => void;
            'notify::disabled-text': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ShortcutLabel.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof ShortcutLabel.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutLabel.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ShortcutLabel.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutLabel.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ShortcutLabel.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ShortcutLabel.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::accel-size-group': (pspec: GObject.ParamSpec) => void;
            'notify::height': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::title-size-group': (pspec: GObject.ParamSpec) => void;
            'notify::view': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ShortcutsGroup.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ShortcutsGroup.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ShortcutsGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsGroup.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ShortcutsGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsGroup.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ShortcutsGroup.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ShortcutsGroup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'change-current-page': (arg0: number) => boolean | void;
            'notify::max-height': (pspec: GObject.ParamSpec) => void;
            'notify::section-name': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::view-name': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ShortcutsSection.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ShortcutsSection.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ShortcutsSection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsSection.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ShortcutsSection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsSection.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ShortcutsSection.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ShortcutsSection.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 ShortcutsShortcut {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::accel-size-group': (pspec: GObject.ParamSpec) => void;
            'notify::accelerator': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::direction': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-set': (pspec: GObject.ParamSpec) => void;
            'notify::shortcut-type': (pspec: GObject.ParamSpec) => void;
            'notify::subtitle': (pspec: GObject.ParamSpec) => void;
            'notify::subtitle-set': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::title-size-group': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ShortcutsShortcut.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ShortcutsShortcut.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ShortcutsShortcut.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsShortcut.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ShortcutsShortcut.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsShortcut.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ShortcutsShortcut.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ShortcutsShortcut.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Window.SignalSignatures {
            close: () => void;
            search: () => void;
            'notify::section-name': (pspec: GObject.ParamSpec) => void;
            'notify::view-name': (pspec: GObject.ParamSpec) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ShortcutsWindow.SignalSignatures;

        // 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<K extends keyof ShortcutsWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsWindow.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ShortcutsWindow.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ShortcutsWindow.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ShortcutsWindow.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ShortcutsWindow.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::ignore-hidden': (pspec: GObject.ParamSpec) => void;
            'notify::mode': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SizeGroup.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SizeGroup.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](mode: SizeGroupMode): SizeGroup;

        // Signals

        connect<K extends keyof SizeGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SizeGroup.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SizeGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SizeGroup.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SizeGroup.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SizeGroup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'plug-added': () => void;
            'plug-removed': () => boolean | void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Socket.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Socket.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Socket;

        // Signals

        connect<K extends keyof Socket.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Socket.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Socket.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Socket.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Socket.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Socket.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class SocketAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<SocketAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SocketAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SocketAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof SocketAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SocketAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SocketAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SocketAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SocketAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SocketAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Entry.SignalSignatures {
            'change-value': (arg0: ScrollType) => void;
            input: (arg0: number) => number;
            output: () => boolean | void;
            'value-changed': () => void;
            wrapped: () => void;
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::climb-rate': (pspec: GObject.ParamSpec) => void;
            'notify::digits': (pspec: GObject.ParamSpec) => void;
            'notify::numeric': (pspec: GObject.ParamSpec) => void;
            'notify::snap-to-ticks': (pspec: GObject.ParamSpec) => void;
            'notify::update-policy': (pspec: GObject.ParamSpec) => void;
            'notify::value': (pspec: GObject.ParamSpec) => void;
            'notify::wrap': (pspec: GObject.ParamSpec) => void;
            'notify::activates-default': (pspec: GObject.ParamSpec) => void;
            'notify::attributes': (pspec: GObject.ParamSpec) => void;
            'notify::buffer': (pspec: GObject.ParamSpec) => void;
            'notify::caps-lock-warning': (pspec: GObject.ParamSpec) => void;
            'notify::completion': (pspec: GObject.ParamSpec) => void;
            'notify::cursor-position': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::enable-emoji-completion': (pspec: GObject.ParamSpec) => void;
            'notify::has-frame': (pspec: GObject.ParamSpec) => void;
            'notify::im-module': (pspec: GObject.ParamSpec) => void;
            'notify::inner-border': (pspec: GObject.ParamSpec) => void;
            'notify::input-hints': (pspec: GObject.ParamSpec) => void;
            'notify::input-purpose': (pspec: GObject.ParamSpec) => void;
            'notify::invisible-char': (pspec: GObject.ParamSpec) => void;
            'notify::invisible-char-set': (pspec: GObject.ParamSpec) => void;
            'notify::max-length': (pspec: GObject.ParamSpec) => void;
            'notify::max-width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::overwrite-mode': (pspec: GObject.ParamSpec) => void;
            'notify::placeholder-text': (pspec: GObject.ParamSpec) => void;
            'notify::populate-all': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-activatable': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-gicon': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-stock': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::primary-icon-tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::progress-fraction': (pspec: GObject.ParamSpec) => void;
            'notify::progress-pulse-step': (pspec: GObject.ParamSpec) => void;
            'notify::scroll-offset': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-activatable': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-gicon': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-stock': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::secondary-icon-tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::selection-bound': (pspec: GObject.ParamSpec) => void;
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::show-emoji-icon': (pspec: GObject.ParamSpec) => void;
            'notify::tabs': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => void;
            'notify::text-length': (pspec: GObject.ParamSpec) => void;
            'notify::truncate-multiline': (pspec: GObject.ParamSpec) => void;
            'notify::visibility': (pspec: GObject.ParamSpec) => void;
            'notify::width-chars': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::editing-canceled': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SpinButton.SignalSignatures;

        // 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<K extends keyof SpinButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SpinButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SpinButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SpinButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SpinButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SpinButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends EntryAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SpinButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SpinButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof SpinButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SpinButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SpinButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SpinButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SpinButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SpinButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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): string;
        /**
         * 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): string;
        /**
         * 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 {
        // Signal signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Spinner.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Spinner.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Spinner;

        // Signals

        connect<K extends keyof Spinner.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Spinner.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Spinner.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Spinner.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Spinner.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Spinner.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SpinnerAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SpinnerAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof SpinnerAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SpinnerAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SpinnerAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SpinnerAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SpinnerAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SpinnerAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::hhomogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::interpolate-size': (pspec: GObject.ParamSpec) => void;
            'notify::transition-duration': (pspec: GObject.ParamSpec) => void;
            'notify::transition-running': (pspec: GObject.ParamSpec) => void;
            'notify::transition-type': (pspec: GObject.ParamSpec) => void;
            'notify::vhomogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::visible-child': (pspec: GObject.ParamSpec) => void;
            'notify::visible-child-name': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Stack.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Stack.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Stack;

        // Signals

        connect<K extends keyof Stack.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Stack.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Stack.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Stack.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Stack.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Stack.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class StackAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<StackAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: StackAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<StackAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof StackAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StackAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof StackAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StackAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof StackAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<StackAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::stack': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: StackSidebar.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<StackSidebar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): StackSidebar;

        // Signals

        connect<K extends keyof StackSidebar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StackSidebar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof StackSidebar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StackSidebar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof StackSidebar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<StackSidebar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::icon-size': (pspec: GObject.ParamSpec) => void;
            'notify::stack': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: StackSwitcher.SignalSignatures;

        // Fields

        widget: Box;

        // Constructors

        constructor(properties?: Partial<StackSwitcher.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): StackSwitcher;

        // Signals

        connect<K extends keyof StackSwitcher.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StackSwitcher.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof StackSwitcher.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StackSwitcher.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof StackSwitcher.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<StackSwitcher.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            activate: () => void;
            'button-press-event': (arg0: Gdk.EventButton) => boolean | void;
            'button-release-event': (arg0: Gdk.EventButton) => boolean | void;
            'popup-menu': (arg0: number, arg1: number) => void;
            'query-tooltip': (arg0: number, arg1: number, arg2: boolean, arg3: Tooltip) => boolean | void;
            'scroll-event': (arg0: Gdk.EventScroll) => boolean | void;
            'size-changed': (arg0: number) => boolean | void;
            'notify::embedded': (pspec: GObject.ParamSpec) => void;
            'notify::file': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
            'notify::pixbuf': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::stock': (pspec: GObject.ParamSpec) => void;
            'notify::storage-type': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: StatusIcon.SignalSignatures;

        // 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<K extends keyof StatusIcon.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StatusIcon.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof StatusIcon.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StatusIcon.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof StatusIcon.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<StatusIcon.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'text-popped': (arg0: number, arg1: string) => void;
            'text-pushed': (arg0: number, arg1: string) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Statusbar.SignalSignatures;

        // Fields

        parent_widget: Box;

        // Constructors

        constructor(properties?: Partial<Statusbar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Statusbar;

        // Signals

        connect<K extends keyof Statusbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Statusbar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Statusbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Statusbar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Statusbar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Statusbar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class StatusbarAccessible extends ContainerAccessible implements Atk.Component {
        static $gtype: GObject.GType<StatusbarAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: StatusbarAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<StatusbarAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof StatusbarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StatusbarAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof StatusbarAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StatusbarAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof StatusbarAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<StatusbarAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            realize: () => void;
            unrealize: () => void;
            'notify::context': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Style.SignalSignatures;

        // 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<K extends keyof Style.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Style.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Style.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Style.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Style.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Style.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            changed: () => void;
            'notify::direction': (pspec: GObject.ParamSpec) => void;
            'notify::paint-clock': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: StyleContext.SignalSignatures;

        // Fields

        parent_object: GObject.Object;

        // Constructors

        constructor(properties?: Partial<StyleContext.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): StyleContext;

        // Signals

        connect<K extends keyof StyleContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StyleContext.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof StyleContext.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StyleContext.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof StyleContext.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<StyleContext.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: StyleProperties.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<StyleProperties.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): StyleProperties;

        // Signals

        connect<K extends keyof StyleProperties.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StyleProperties.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof StyleProperties.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, StyleProperties.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof StyleProperties.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<StyleProperties.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Widget.SignalSignatures {
            activate: () => void;
            'state-set': (arg0: boolean) => boolean | void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::state': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Switch.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Switch.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Switch;

        // Signals

        connect<K extends keyof Switch.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Switch.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Switch.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Switch.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Switch.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Switch.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends WidgetAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: SwitchAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<SwitchAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof SwitchAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SwitchAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof SwitchAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, SwitchAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof SwitchAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<SwitchAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::column-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::n-columns': (pspec: GObject.ParamSpec) => void;
            'notify::n-rows': (pspec: GObject.ParamSpec) => void;
            'notify::row-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Table.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Table.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](rows: number, columns: number, homogeneous: boolean): Table;

        // Signals

        connect<K extends keyof Table.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Table.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Table.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Table.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Table.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Table.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends MenuItem.SignalSignatures {
            'notify::accel-path': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::right-justified': (pspec: GObject.ParamSpec) => void;
            'notify::submenu': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TearoffMenuItem.SignalSignatures;

        // Fields

        menu_item: MenuItem;

        // Constructors

        constructor(properties?: Partial<TearoffMenuItem.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): TearoffMenuItem;

        // Signals

        connect<K extends keyof TearoffMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TearoffMenuItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TearoffMenuItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TearoffMenuItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TearoffMenuItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TearoffMenuItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 TextBuffer {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'apply-tag': (arg0: TextTag, arg1: TextIter, arg2: TextIter) => void;
            'begin-user-action': () => void;
            changed: () => void;
            'delete-range': (arg0: TextIter, arg1: TextIter) => void;
            'end-user-action': () => void;
            'insert-child-anchor': (arg0: TextIter, arg1: TextChildAnchor) => void;
            'insert-pixbuf': (arg0: TextIter, arg1: GdkPixbuf.Pixbuf) => void;
            'insert-text': (arg0: TextIter, arg1: string, arg2: number) => void;
            'mark-deleted': (arg0: TextMark) => void;
            'mark-set': (arg0: TextIter, arg1: TextMark) => void;
            'modified-changed': () => void;
            'paste-done': (arg0: Clipboard) => void;
            'remove-tag': (arg0: TextTag, arg1: TextIter, arg2: TextIter) => void;
            'notify::copy-target-list': (pspec: GObject.ParamSpec) => void;
            'notify::cursor-position': (pspec: GObject.ParamSpec) => void;
            'notify::has-selection': (pspec: GObject.ParamSpec) => void;
            'notify::paste-target-list': (pspec: GObject.ParamSpec) => void;
            'notify::tag-table': (pspec: GObject.ParamSpec) => void;
            'notify::text': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextBuffer.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextBuffer.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](table?: TextTagTable | null): TextBuffer;

        // Signals

        connect<K extends keyof TextBuffer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextBuffer.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextBuffer.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextBuffer.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextBuffer.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextBuffer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends RendererCellAccessible.SignalSignatures {
            'notify::renderer': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextCellAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextCellAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof TextCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextCellAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextCellAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextCellAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextCellAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextCellAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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): string;
        /**
         * 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): string;
        /**
         * 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextChildAnchor.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextChildAnchor.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): TextChildAnchor;

        // Signals

        connect<K extends keyof TextChildAnchor.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextChildAnchor.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextChildAnchor.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextChildAnchor.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextChildAnchor.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextChildAnchor.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::left-gravity': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextMark.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextMark.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](name: string | null, left_gravity: boolean): TextMark;

        // Signals

        connect<K extends keyof TextMark.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextMark.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextMark.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextMark.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextMark.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextMark.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            event: (arg0: GObject.Object, arg1: Gdk.Event, arg2: TextIter) => boolean | void;
            'notify::accumulative-margin': (pspec: GObject.ParamSpec) => void;
            'notify::background': (pspec: GObject.ParamSpec) => void;
            'notify::background-full-height': (pspec: GObject.ParamSpec) => void;
            'notify::background-full-height-set': (pspec: GObject.ParamSpec) => void;
            'notify::background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::background-set': (pspec: GObject.ParamSpec) => void;
            'notify::direction': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::editable-set': (pspec: GObject.ParamSpec) => void;
            'notify::fallback': (pspec: GObject.ParamSpec) => void;
            'notify::fallback-set': (pspec: GObject.ParamSpec) => void;
            'notify::family': (pspec: GObject.ParamSpec) => void;
            'notify::family-set': (pspec: GObject.ParamSpec) => void;
            'notify::font': (pspec: GObject.ParamSpec) => void;
            'notify::font-desc': (pspec: GObject.ParamSpec) => void;
            'notify::font-features': (pspec: GObject.ParamSpec) => void;
            'notify::font-features-set': (pspec: GObject.ParamSpec) => void;
            'notify::foreground': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::foreground-set': (pspec: GObject.ParamSpec) => void;
            'notify::indent': (pspec: GObject.ParamSpec) => void;
            'notify::indent-set': (pspec: GObject.ParamSpec) => void;
            'notify::invisible': (pspec: GObject.ParamSpec) => void;
            'notify::invisible-set': (pspec: GObject.ParamSpec) => void;
            'notify::justification': (pspec: GObject.ParamSpec) => void;
            'notify::justification-set': (pspec: GObject.ParamSpec) => void;
            'notify::language': (pspec: GObject.ParamSpec) => void;
            'notify::language-set': (pspec: GObject.ParamSpec) => void;
            'notify::left-margin': (pspec: GObject.ParamSpec) => void;
            'notify::left-margin-set': (pspec: GObject.ParamSpec) => void;
            'notify::letter-spacing': (pspec: GObject.ParamSpec) => void;
            'notify::letter-spacing-set': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::paragraph-background': (pspec: GObject.ParamSpec) => void;
            'notify::paragraph-background-gdk': (pspec: GObject.ParamSpec) => void;
            'notify::paragraph-background-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::paragraph-background-set': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-above-lines': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-above-lines-set': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-below-lines': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-below-lines-set': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-inside-wrap': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-inside-wrap-set': (pspec: GObject.ParamSpec) => void;
            'notify::right-margin': (pspec: GObject.ParamSpec) => void;
            'notify::right-margin-set': (pspec: GObject.ParamSpec) => void;
            'notify::rise': (pspec: GObject.ParamSpec) => void;
            'notify::rise-set': (pspec: GObject.ParamSpec) => void;
            'notify::scale': (pspec: GObject.ParamSpec) => void;
            'notify::scale-set': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::size-points': (pspec: GObject.ParamSpec) => void;
            'notify::size-set': (pspec: GObject.ParamSpec) => void;
            'notify::stretch': (pspec: GObject.ParamSpec) => void;
            'notify::stretch-set': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough-rgba-set': (pspec: GObject.ParamSpec) => void;
            'notify::strikethrough-set': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::style-set': (pspec: GObject.ParamSpec) => void;
            'notify::tabs': (pspec: GObject.ParamSpec) => void;
            'notify::tabs-set': (pspec: GObject.ParamSpec) => void;
            'notify::underline': (pspec: GObject.ParamSpec) => void;
            'notify::underline-rgba': (pspec: GObject.ParamSpec) => void;
            'notify::underline-rgba-set': (pspec: GObject.ParamSpec) => void;
            'notify::underline-set': (pspec: GObject.ParamSpec) => void;
            'notify::variant': (pspec: GObject.ParamSpec) => void;
            'notify::variant-set': (pspec: GObject.ParamSpec) => void;
            'notify::weight': (pspec: GObject.ParamSpec) => void;
            'notify::weight-set': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode-set': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextTag.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextTag.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](name?: string | null): TextTag;

        // Signals

        connect<K extends keyof TextTag.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextTag.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextTag.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextTag.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextTag.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextTag.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'tag-added': (arg0: TextTag) => void;
            'tag-changed': (arg0: TextTag, arg1: boolean) => void;
            'tag-removed': (arg0: 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextTagTable.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextTagTable.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): TextTagTable;

        // Signals

        connect<K extends keyof TextTagTable.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextTagTable.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextTagTable.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextTagTable.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextTagTable.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextTagTable.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            backspace: () => void;
            'copy-clipboard': () => void;
            'cut-clipboard': () => void;
            'delete-from-cursor': (arg0: DeleteType, arg1: number) => void;
            'extend-selection': (
                arg0: TextExtendSelection,
                arg1: TextIter,
                arg2: TextIter,
                arg3: TextIter,
            ) => boolean | void;
            'insert-at-cursor': (arg0: string) => void;
            'insert-emoji': () => void;
            'move-cursor': (arg0: MovementStep, arg1: number, arg2: boolean) => void;
            'move-viewport': (arg0: ScrollStep, arg1: number) => void;
            'paste-clipboard': () => void;
            'populate-popup': (arg0: Widget) => void;
            'preedit-changed': (arg0: string) => void;
            'select-all': (arg0: boolean) => void;
            'set-anchor': () => void;
            'toggle-cursor-visible': () => void;
            'toggle-overwrite': () => void;
            'notify::accepts-tab': (pspec: GObject.ParamSpec) => void;
            'notify::bottom-margin': (pspec: GObject.ParamSpec) => void;
            'notify::buffer': (pspec: GObject.ParamSpec) => void;
            'notify::cursor-visible': (pspec: GObject.ParamSpec) => void;
            'notify::editable': (pspec: GObject.ParamSpec) => void;
            'notify::im-module': (pspec: GObject.ParamSpec) => void;
            'notify::indent': (pspec: GObject.ParamSpec) => void;
            'notify::input-hints': (pspec: GObject.ParamSpec) => void;
            'notify::input-purpose': (pspec: GObject.ParamSpec) => void;
            'notify::justification': (pspec: GObject.ParamSpec) => void;
            'notify::left-margin': (pspec: GObject.ParamSpec) => void;
            'notify::monospace': (pspec: GObject.ParamSpec) => void;
            'notify::overwrite': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-above-lines': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-below-lines': (pspec: GObject.ParamSpec) => void;
            'notify::pixels-inside-wrap': (pspec: GObject.ParamSpec) => void;
            'notify::populate-all': (pspec: GObject.ParamSpec) => void;
            'notify::right-margin': (pspec: GObject.ParamSpec) => void;
            'notify::tabs': (pspec: GObject.ParamSpec) => void;
            'notify::top-margin': (pspec: GObject.ParamSpec) => void;
            'notify::wrap-mode': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscroll-policy': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscroll-policy': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextView.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextView.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): TextView;

        static new_with_buffer(buffer: TextBuffer): TextView;

        // Signals

        connect<K extends keyof TextView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextView.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextView.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextView.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextView.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TextViewAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TextViewAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof TextViewAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextViewAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TextViewAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TextViewAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TextViewAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TextViewAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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): string;
        /**
         * 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): string;
        /**
         * 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::name': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ThemingEngine.SignalSignatures;

        // Fields

        parent_object: GObject.Object;

        // Constructors

        constructor(properties?: Partial<ThemingEngine.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ThemingEngine.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ThemingEngine.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ThemingEngine.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ThemingEngine.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ThemingEngine.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ThemingEngine.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Action.SignalSignatures {
            toggled: () => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-as-radio': (pspec: GObject.ParamSpec) => void;
            'notify::action-group': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::gicon': (pspec: GObject.ParamSpec) => void;
            'notify::hide-if-empty': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::short-label': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-overflown': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToggleAction.SignalSignatures;

        // 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<K extends keyof ToggleAction.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleAction.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToggleAction.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleAction.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToggleAction.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToggleAction.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Button.SignalSignatures {
            toggled: () => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::draw-indicator': (pspec: GObject.ParamSpec) => void;
            'notify::inconsistent': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToggleButton.SignalSignatures;

        // 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<K extends keyof ToggleButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToggleButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToggleButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToggleButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ButtonAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToggleButtonAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ToggleButtonAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ToggleButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToggleButtonAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleButtonAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToggleButtonAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToggleButtonAccessible.SignalSignatures[K]> extends [any, ...infer Q]
                ? Q
                : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends ToolButton.SignalSignatures {
            toggled: () => void;
            'notify::active': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::icon-widget': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToggleToolButton.SignalSignatures;

        // 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<K extends keyof ToggleToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleToolButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToggleToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToggleToolButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToggleToolButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToggleToolButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends ToolItem.SignalSignatures {
            clicked: () => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::icon-widget': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::stock-id': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::action-name': (pspec: GObject.ParamSpec) => void;
            'notify::action-target': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToolButton.SignalSignatures;

        // 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<K extends keyof ToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToolButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToolButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToolButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'create-menu-proxy': () => boolean | void;
            'toolbar-reconfigured': () => void;
            'notify::is-important': (pspec: GObject.ParamSpec) => void;
            'notify::visible-horizontal': (pspec: GObject.ParamSpec) => void;
            'notify::visible-vertical': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::related-action': (pspec: GObject.ParamSpec) => void;
            'notify::use-action-appearance': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToolItem.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ToolItem.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ToolItem;

        // Signals

        connect<K extends keyof ToolItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolItem.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToolItem.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolItem.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToolItem.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToolItem.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::collapsed': (pspec: GObject.ParamSpec) => void;
            'notify::ellipsize': (pspec: GObject.ParamSpec) => void;
            'notify::header-relief': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::label-widget': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToolItemGroup.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ToolItemGroup.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](label: string): ToolItemGroup;

        // Signals

        connect<K extends keyof ToolItemGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolItemGroup.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToolItemGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolItemGroup.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToolItemGroup.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToolItemGroup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'notify::icon-size': (pspec: GObject.ParamSpec) => void;
            'notify::icon-size-set': (pspec: GObject.ParamSpec) => void;
            'notify::toolbar-style': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscroll-policy': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscroll-policy': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToolPalette.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ToolPalette.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): ToolPalette;

        // Signals

        connect<K extends keyof ToolPalette.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolPalette.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToolPalette.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToolPalette.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToolPalette.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToolPalette.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'focus-home-or-end': (arg0: boolean) => boolean | void;
            'orientation-changed': (arg0: Orientation) => void;
            'popup-context-menu': (arg0: number, arg1: number, arg2: number) => boolean | void;
            'style-changed': (arg0: ToolbarStyle) => void;
            'notify::icon-size': (pspec: GObject.ParamSpec) => void;
            'notify::icon-size-set': (pspec: GObject.ParamSpec) => void;
            'notify::show-arrow': (pspec: GObject.ParamSpec) => void;
            'notify::toolbar-style': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Toolbar.SignalSignatures;

        // Fields

        container: Container;

        // Constructors

        constructor(properties?: Partial<Toolbar.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): Toolbar;

        // Signals

        connect<K extends keyof Toolbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Toolbar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Toolbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Toolbar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Toolbar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Toolbar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Tooltip.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Tooltip.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Tooltip.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Tooltip.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Tooltip.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Tooltip.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Tooltip.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Tooltip.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends Atk.Object.SignalSignatures {
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends Atk.Object.ConstructorProps {}
    }

    class ToplevelAccessible extends Atk.Object {
        static $gtype: GObject.GType<ToplevelAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: ToplevelAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<ToplevelAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof ToplevelAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToplevelAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof ToplevelAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, ToplevelAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof ToplevelAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<ToplevelAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // Methods

        get_children(): Window[];
    }

    namespace TreeModelFilter {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::child-model': (pspec: GObject.ParamSpec) => void;
            'notify::virtual-root': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TreeModelFilter.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TreeModelFilter.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof TreeModelFilter.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeModelFilter.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TreeModelFilter.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeModelFilter.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TreeModelFilter.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TreeModelFilter.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'notify::model': (pspec: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TreeModelSort.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TreeModelSort.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static new_with_model(child_model: TreeModel): TreeModelSort;

        // Signals

        connect<K extends keyof TreeModelSort.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeModelSort.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TreeModelSort.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeModelSort.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TreeModelSort.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TreeModelSort.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            changed: () => void;
            'notify::mode': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TreeSelection.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TreeSelection.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof TreeSelection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeSelection.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TreeSelection.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeSelection.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TreeSelection.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TreeSelection.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TreeStore.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TreeStore.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](types: GObject.GType[]): TreeStore;

        // Signals

        connect<K extends keyof TreeStore.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeStore.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TreeStore.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeStore.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TreeStore.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TreeStore.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 signatures
        interface SignalSignatures extends Container.SignalSignatures {
            'columns-changed': () => void;
            'cursor-changed': () => void;
            'expand-collapse-cursor-row': (arg0: boolean, arg1: boolean, arg2: boolean) => boolean | void;
            'move-cursor': (arg0: MovementStep, arg1: number) => boolean | void;
            'row-activated': (arg0: TreePath, arg1: TreeViewColumn) => void;
            'row-collapsed': (arg0: TreeIter, arg1: TreePath) => void;
            'row-expanded': (arg0: TreeIter, arg1: TreePath) => void;
            'select-all': () => boolean | void;
            'select-cursor-parent': () => boolean | void;
            'select-cursor-row': (arg0: boolean) => boolean | void;
            'start-interactive-search': () => boolean | void;
            'test-collapse-row': (arg0: TreeIter, arg1: TreePath) => boolean | void;
            'test-expand-row': (arg0: TreeIter, arg1: TreePath) => boolean | void;
            'toggle-cursor-row': () => boolean | void;
            'unselect-all': () => boolean | void;
            'notify::activate-on-single-click': (pspec: GObject.ParamSpec) => void;
            'notify::enable-grid-lines': (pspec: GObject.ParamSpec) => void;
            'notify::enable-search': (pspec: GObject.ParamSpec) => void;
            'notify::enable-tree-lines': (pspec: GObject.ParamSpec) => void;
            'notify::expander-column': (pspec: GObject.ParamSpec) => void;
            'notify::fixed-height-mode': (pspec: GObject.ParamSpec) => void;
            'notify::headers-clickable': (pspec: GObject.ParamSpec) => void;
            'notify::headers-visible': (pspec: GObject.ParamSpec) => void;
            'notify::hover-expand': (pspec: GObject.ParamSpec) => void;
            'notify::hover-selection': (pspec: GObject.ParamSpec) => void;
            'notify::level-indentation': (pspec: GObject.ParamSpec) => void;
            'notify::model': (pspec: GObject.ParamSpec) => void;
            'notify::reorderable': (pspec: GObject.ParamSpec) => void;
            'notify::rubber-banding': (pspec: GObject.ParamSpec) => void;
            'notify::rules-hint': (pspec: GObject.ParamSpec) => void;
            'notify::search-column': (pspec: GObject.ParamSpec) => void;
            'notify::show-expanders': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-column': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscroll-policy': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscroll-policy': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TreeView.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TreeView.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): TreeView;

        static new_with_model(model: TreeModel): TreeView;

        // Signals

        connect<K extends keyof TreeView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeView.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TreeView.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeView.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TreeView.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TreeView.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TreeViewAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TreeViewAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof TreeViewAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeViewAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TreeViewAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeViewAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TreeViewAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TreeViewAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends GObject.InitiallyUnowned.SignalSignatures {
            clicked: () => void;
            'notify::alignment': (pspec: GObject.ParamSpec) => void;
            'notify::cell-area': (pspec: GObject.ParamSpec) => void;
            'notify::clickable': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::fixed-width': (pspec: GObject.ParamSpec) => void;
            'notify::max-width': (pspec: GObject.ParamSpec) => void;
            'notify::min-width': (pspec: GObject.ParamSpec) => void;
            'notify::reorderable': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::sizing': (pspec: GObject.ParamSpec) => void;
            'notify::sort-column-id': (pspec: GObject.ParamSpec) => void;
            'notify::sort-indicator': (pspec: GObject.ParamSpec) => void;
            'notify::sort-order': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::width': (pspec: GObject.ParamSpec) => void;
            'notify::x-offset': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: TreeViewColumn.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<TreeViewColumn.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): TreeViewColumn;

        static new_with_area(area: CellArea): TreeViewColumn;

        // Signals

        connect<K extends keyof TreeViewColumn.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeViewColumn.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof TreeViewColumn.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, TreeViewColumn.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof TreeViewColumn.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<TreeViewColumn.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {
            'actions-changed': () => void;
            'add-widget': (arg0: Widget) => void;
            'connect-proxy': (arg0: Action, arg1: Widget) => void;
            'disconnect-proxy': (arg0: Action, arg1: Widget) => void;
            'post-activate': (arg0: Action) => void;
            'pre-activate': (arg0: Action) => void;
            'notify::add-tearoffs': (pspec: GObject.ParamSpec) => void;
            'notify::ui': (pspec: GObject.ParamSpec) => 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: UIManager.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<UIManager.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): UIManager;

        // Signals

        connect<K extends keyof UIManager.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, UIManager.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof UIManager.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, UIManager.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof UIManager.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<UIManager.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Box.SignalSignatures {
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: VBox.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof VBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof VBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof VBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<VBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 VButtonBox {
        // Signal signatures
        interface SignalSignatures extends ButtonBox.SignalSignatures {
            'notify::layout-style': (pspec: GObject.ParamSpec) => void;
            'notify::baseline-position': (pspec: GObject.ParamSpec) => void;
            'notify::homogeneous': (pspec: GObject.ParamSpec) => void;
            'notify::spacing': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: VButtonBox.SignalSignatures;

        // Fields

        button_box: ButtonBox;

        // Constructors

        constructor(properties?: Partial<VButtonBox.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): VButtonBox;

        // Signals

        connect<K extends keyof VButtonBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VButtonBox.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof VButtonBox.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VButtonBox.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof VButtonBox.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<VButtonBox.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 VPaned {
        // Signal signatures
        interface SignalSignatures extends Paned.SignalSignatures {
            'notify::max-position': (pspec: GObject.ParamSpec) => void;
            'notify::min-position': (pspec: GObject.ParamSpec) => void;
            'notify::position': (pspec: GObject.ParamSpec) => void;
            'notify::position-set': (pspec: GObject.ParamSpec) => void;
            'notify::wide-handle': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: VPaned.SignalSignatures;

        // Fields

        paned: Paned;

        // Constructors

        constructor(properties?: Partial<VPaned.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): VPaned;

        // Signals

        connect<K extends keyof VPaned.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VPaned.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof VPaned.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VPaned.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof VPaned.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<VPaned.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 VScale {
        // Signal signatures
        interface SignalSignatures extends Scale.SignalSignatures {
            'notify::digits': (pspec: GObject.ParamSpec) => void;
            'notify::draw-value': (pspec: GObject.ParamSpec) => void;
            'notify::has-origin': (pspec: GObject.ParamSpec) => void;
            'notify::value-pos': (pspec: GObject.ParamSpec) => void;
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::lower-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::restrict-to-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::round-digits': (pspec: GObject.ParamSpec) => void;
            'notify::show-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::upper-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: VScale.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof VScale.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VScale.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof VScale.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VScale.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof VScale.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<VScale.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 VScrollbar {
        // Signal signatures
        interface SignalSignatures extends Scrollbar.SignalSignatures {
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::inverted': (pspec: GObject.ParamSpec) => void;
            'notify::lower-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::restrict-to-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::round-digits': (pspec: GObject.ParamSpec) => void;
            'notify::show-fill-level': (pspec: GObject.ParamSpec) => void;
            'notify::upper-stepper-sensitivity': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: VScrollbar.SignalSignatures;

        // 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;

        // Signals

        connect<K extends keyof VScrollbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VScrollbar.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof VScrollbar.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VScrollbar.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof VScrollbar.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<VScrollbar.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 VSeparator {
        // Signal signatures
        interface SignalSignatures extends Separator.SignalSignatures {
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: VSeparator.SignalSignatures;

        // Fields

        separator: Separator;

        // Constructors

        constructor(properties?: Partial<VSeparator.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): VSeparator;

        // Signals

        connect<K extends keyof VSeparator.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VSeparator.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof VSeparator.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VSeparator.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof VSeparator.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<VSeparator.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 Viewport {
        // Signal signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'notify::shadow-type': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::hadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::hscroll-policy': (pspec: GObject.ParamSpec) => void;
            'notify::vadjustment': (pspec: GObject.ParamSpec) => void;
            'notify::vscroll-policy': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Viewport.SignalSignatures;

        // Fields

        bin: Bin;

        // Constructors

        constructor(properties?: Partial<Viewport.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](hadjustment?: Adjustment | null, vadjustment?: Adjustment | null): Viewport;

        // Signals

        connect<K extends keyof Viewport.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Viewport.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Viewport.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Viewport.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Viewport.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Viewport.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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 {
        // Signal signatures
        interface SignalSignatures extends ScaleButton.SignalSignatures {
            'notify::use-symbolic': (pspec: GObject.ParamSpec) => void;
            'notify::adjustment': (pspec: GObject.ParamSpec) => void;
            'notify::icons': (pspec: GObject.ParamSpec) => void;
            'notify::size': (pspec: GObject.ParamSpec) => void;
            'notify::value': (pspec: GObject.ParamSpec) => void;
            'notify::always-show-image': (pspec: GObject.ParamSpec) => void;
            'notify::image': (pspec: GObject.ParamSpec) => void;
            'notify::image-position': (pspec: GObject.ParamSpec) => void;
            'notify::label': (pspec: GObject.ParamSpec) => void;
            'notify::relief': (pspec: GObject.ParamSpec) => void;
            'notify::use-stock': (pspec: GObject.ParamSpec) => void;
            'notify::use-underline': (pspec: GObject.ParamSpec) => void;
            'notify::xalign': (pspec: GObject.ParamSpec) => void;
            'notify::yalign': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'notify::orientation': (pspec: GObject.ParamSpec) => void;
        }

        // 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: VolumeButton.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<VolumeButton.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): VolumeButton;

        // Signals

        connect<K extends keyof VolumeButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VolumeButton.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof VolumeButton.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, VolumeButton.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof VolumeButton.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<VolumeButton.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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;
        /**
         * Creates a binding between `source_property` on `source` and `target_property`
         * on `target`.
         *
         * Whenever the `source_property` is changed the `target_property` is
         * updated using the same value. For instance:
         *
         *
         * ```c
         *   g_object_bind_property (action, "active", widget, "sensitive", 0);
         * ```
         *
         *
         * Will result in the "sensitive" property of the widget #GObject instance to be
         * updated with the same value of the "active" property of the action #GObject
         * instance.
         *
         * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
         * if `target_property` on `target` changes then the `source_property` on `source`
         * will be updated as well.
         *
         * The binding will automatically be removed when either the `source` or the
         * `target` instances are finalized. To remove the binding without affecting the
         * `source` and the `target` you can just call g_object_unref() on the returned
         * #GBinding instance.
         *
         * Removing the binding by calling g_object_unref() on it must only be done if
         * the binding, `source` and `target` are only used from a single thread and it
         * is clear that both `source` and `target` outlive the binding. Especially it
         * is not safe to rely on this if the binding, `source` or `target` can be
         * finalized from different threads. Keep another reference to the binding and
         * use g_binding_unbind() instead to be on the safe side.
         *
         * A #GObject can have multiple bindings.
         * @param source_property the property on @source to bind
         * @param target the target #GObject
         * @param target_property the property on @target to bind
         * @param flags flags to pass to #GBinding
         * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
         */
        bind_property(
            source_property: string,
            target: GObject.Object,
            target_property: string,
            flags: GObject.BindingFlags | null,
        ): GObject.Binding;
        /**
         * Complete version of g_object_bind_property().
         *
         * Creates a binding between `source_property` on `source` and `target_property`
         * on `target,` allowing you to set the transformation functions to be used by
         * the binding.
         *
         * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
         * if `target_property` on `target` changes then the `source_property` on `source`
         * will be updated as well. The `transform_from` function is only used in case
         * of bidirectional bindings, otherwise it will be ignored
         *
         * The binding will automatically be removed when either the `source` or the
         * `target` instances are finalized. This will release the reference that is
         * being held on the #GBinding instance; if you want to hold on to the
         * #GBinding instance, you will need to hold a reference to it.
         *
         * To remove the binding, call g_binding_unbind().
         *
         * A #GObject can have multiple bindings.
         *
         * The same `user_data` parameter will be used for both `transform_to`
         * and `transform_from` transformation functions; the `notify` function will
         * be called once, when the binding is removed. If you need different data
         * for each transformation function, please use
         * g_object_bind_property_with_closures() instead.
         * @param source_property the property on @source to bind
         * @param target the target #GObject
         * @param target_property the property on @target to bind
         * @param flags flags to pass to #GBinding
         * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
         * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
         * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
         * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
         */
        bind_property_full(
            source_property: string,
            target: GObject.Object,
            target_property: string,
            flags: GObject.BindingFlags | null,
            transform_to?: GObject.BindingTransformFunc | null,
            transform_from?: GObject.BindingTransformFunc | null,
            notify?: GLib.DestroyNotify | null,
        ): GObject.Binding;
        // Conflicted with GObject.Object.bind_property_full
        bind_property_full(...args: never[]): any;
        /**
         * This function is intended for #GObject implementations to re-enforce
         * a [floating][floating-ref] object reference. Doing this is seldom
         * required: all #GInitiallyUnowneds are created with a floating reference
         * which usually just needs to be sunken by calling g_object_ref_sink().
         */
        force_floating(): void;
        /**
         * Increases the freeze count on `object`. If the freeze count is
         * non-zero, the emission of "notify" signals on `object` is
         * stopped. The signals are queued until the freeze count is decreased
         * to zero. Duplicate notifications are squashed so that at most one
         * #GObject::notify signal is emitted for each property modified while the
         * object is frozen.
         *
         * This is necessary for accessors that modify multiple properties to prevent
         * premature notification while the object is still being modified.
         */
        freeze_notify(): void;
        /**
         * Gets a named field from the objects table of associations (see g_object_set_data()).
         * @param key name of the key for that association
         * @returns the data if found,          or %NULL if no such data exists.
         */
        get_data(key: string): any | null;
        /**
         * Gets a property of an object.
         *
         * The value can be:
         * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
         * - a GObject.Value initialized with the expected type of the property
         * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
         *
         * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
         *
         * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
         * @param property_name The name of the property to get
         * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
         */
        get_property(property_name: string, value: GObject.Value | any): any;
        /**
         * This function gets back user data pointers stored via
         * g_object_set_qdata().
         * @param quark A #GQuark, naming the user data pointer
         * @returns The user data pointer set, or %NULL
         */
        get_qdata(quark: GLib.Quark): any | null;
        /**
         * Gets `n_properties` properties for an `object`.
         * Obtained properties will be set to `values`. All properties must be valid.
         * Warnings will be emitted and undefined behaviour may result if invalid
         * properties are passed in.
         * @param names the names of each property to get
         * @param values the values of each property to get
         */
        getv(names: string[], values: (GObject.Value | any)[]): void;
        /**
         * Checks whether `object` has a [floating][floating-ref] reference.
         * @returns %TRUE if @object has a floating reference
         */
        is_floating(): boolean;
        /**
         * Emits a "notify" signal for the property `property_name` on `object`.
         *
         * When possible, eg. when signaling a property change from within the class
         * that registered the property, you should use g_object_notify_by_pspec()
         * instead.
         *
         * Note that emission of the notify signal may be blocked with
         * g_object_freeze_notify(). In this case, the signal emissions are queued
         * and will be emitted (in reverse order) when g_object_thaw_notify() is
         * called.
         * @param property_name the name of a property installed on the class of @object.
         */
        notify(property_name: string): void;
        /**
         * Emits a "notify" signal for the property specified by `pspec` on `object`.
         *
         * This function omits the property name lookup, hence it is faster than
         * g_object_notify().
         *
         * One way to avoid using g_object_notify() from within the
         * class that registered the properties, and using g_object_notify_by_pspec()
         * instead, is to store the GParamSpec used with
         * g_object_class_install_property() inside a static array, e.g.:
         *
         *
         * ```c
         *   typedef enum
         *   {
         *     PROP_FOO = 1,
         *     PROP_LAST
         *   } MyObjectProperty;
         *
         *   static GParamSpec *properties[PROP_LAST];
         *
         *   static void
         *   my_object_class_init (MyObjectClass *klass)
         *   {
         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
         *                                              0, 100,
         *                                              50,
         *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
         *     g_object_class_install_property (gobject_class,
         *                                      PROP_FOO,
         *                                      properties[PROP_FOO]);
         *   }
         * ```
         *
         *
         * and then notify a change on the "foo" property with:
         *
         *
         * ```c
         *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
         * ```
         *
         * @param pspec the #GParamSpec of a property installed on the class of @object.
         */
        notify_by_pspec(pspec: GObject.ParamSpec): void;
        /**
         * Increases the reference count of `object`.
         *
         * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
         * of `object` will be propagated to the return type (using the GCC typeof()
         * extension), so any casting the caller needs to do on the return type must be
         * explicit.
         * @returns the same @object
         */
        ref(): GObject.Object;
        /**
         * Increase the reference count of `object,` and possibly remove the
         * [floating][floating-ref] reference, if `object` has a floating reference.
         *
         * In other words, if the object is floating, then this call "assumes
         * ownership" of the floating reference, converting it to a normal
         * reference by clearing the floating flag while leaving the reference
         * count unchanged.  If the object is not floating, then this call
         * adds a new normal reference increasing the reference count by one.
         *
         * Since GLib 2.56, the type of `object` will be propagated to the return type
         * under the same conditions as for g_object_ref().
         * @returns @object
         */
        ref_sink(): GObject.Object;
        /**
         * Releases all references to other objects. This can be used to break
         * reference cycles.
         *
         * This function should only be called from object system implementations.
         */
        run_dispose(): void;
        /**
         * Each object carries around a table of associations from
         * strings to pointers.  This function lets you set an association.
         *
         * If the object already had an association with that name,
         * the old association will be destroyed.
         *
         * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
         * This means a copy of `key` is kept permanently (even after `object` has been
         * finalized) — so it is recommended to only use a small, bounded set of values
         * for `key` in your program, to avoid the #GQuark storage growing unbounded.
         * @param key name of the key
         * @param data data to associate with that key
         */
        set_data(key: string, data?: any | null): void;
        /**
         * Sets a property on an object.
         * @param property_name The name of the property to set
         * @param value The value to set the property to
         */
        set_property(property_name: string, value: GObject.Value | any): void;
        /**
         * Remove a specified datum from the object's data associations,
         * without invoking the association's destroy handler.
         * @param key name of the key
         * @returns the data if found, or %NULL          if no such data exists.
         */
        steal_data(key: string): any | null;
        /**
         * This function gets back user data pointers stored via
         * g_object_set_qdata() and removes the `data` from object
         * without invoking its destroy() function (if any was
         * set).
         * Usually, calling this function is only required to update
         * user data pointers with a destroy notifier, for example:
         *
         * ```c
         * void
         * object_add_to_user_list (GObject     *object,
         *                          const gchar *new_string)
         * {
         *   // the quark, naming the object data
         *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
         *   // retrieve the old string list
         *   GList *list = g_object_steal_qdata (object, quark_string_list);
         *
         *   // prepend new string
         *   list = g_list_prepend (list, g_strdup (new_string));
         *   // this changed 'list', so we need to set it again
         *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
         * }
         * static void
         * free_string_list (gpointer data)
         * {
         *   GList *node, *list = data;
         *
         *   for (node = list; node; node = node->next)
         *     g_free (node->data);
         *   g_list_free (list);
         * }
         * ```
         *
         * Using g_object_get_qdata() in the above example, instead of
         * g_object_steal_qdata() would have left the destroy function set,
         * and thus the partial string list would have been freed upon
         * g_object_set_qdata_full().
         * @param quark A #GQuark, naming the user data pointer
         * @returns The user data pointer set, or %NULL
         */
        steal_qdata(quark: GLib.Quark): any | null;
        /**
         * Reverts the effect of a previous call to
         * g_object_freeze_notify(). The freeze count is decreased on `object`
         * and when it reaches zero, queued "notify" signals are emitted.
         *
         * Duplicate notifications for each property are squashed so that at most one
         * #GObject::notify signal is emitted for each property, in the reverse order
         * in which they have been queued.
         *
         * It is an error to call this function when the freeze count is zero.
         */
        thaw_notify(): void;
        /**
         * Decreases the reference count of `object`. When its reference count
         * drops to 0, the object is finalized (i.e. its memory is freed).
         *
         * If the pointer to the #GObject may be reused in future (for example, if it is
         * an instance variable of another object), it is recommended to clear the
         * pointer to %NULL rather than retain a dangling pointer to a potentially
         * invalid #GObject instance. Use g_clear_object() for this.
         */
        unref(): void;
        /**
         * This function essentially limits the life time of the `closure` to
         * the life time of the object. That is, when the object is finalized,
         * the `closure` is invalidated by calling g_closure_invalidate() on
         * it, in order to prevent invocations of the closure with a finalized
         * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
         * added as marshal guards to the `closure,` to ensure that an extra
         * reference count is held on `object` during invocation of the
         * `closure`.  Usually, this function will be called on closures that
         * use this `object` as closure data.
         * @param closure #GClosure to watch
         */
        watch_closure(closure: GObject.Closure): void;
        /**
         * the `constructed` function is called by g_object_new() as the
         *  final step of the object creation process.  At the point of the call, all
         *  construction properties have been set on the object.  The purpose of this
         *  call is to allow for object initialisation steps that can only be performed
         *  after construction properties have been set.  `constructed` implementors
         *  should chain up to the `constructed` call of their parent class to allow it
         *  to complete its initialisation.
         */
        vfunc_constructed(): void;
        /**
         * emits property change notification for a bunch
         *  of properties. Overriding `dispatch_properties_changed` should be rarely
         *  needed.
         * @param n_pspecs
         * @param pspecs
         */
        vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
        /**
         * the `dispose` function is supposed to drop all references to other
         *  objects, but keep the instance otherwise intact, so that client method
         *  invocations still work. It may be run multiple times (due to reference
         *  loops). Before returning, `dispose` should chain up to the `dispose` method
         *  of the parent class.
         */
        vfunc_dispose(): void;
        /**
         * instance finalization function, should finish the finalization of
         *  the instance begun in `dispose` and chain up to the `finalize` method of the
         *  parent class.
         */
        vfunc_finalize(): void;
        /**
         * the generic getter for all properties of this type. Should be
         *  overridden for every type with properties.
         * @param property_id
         * @param value
         * @param pspec
         */
        vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
        /**
         * Emits a "notify" signal for the property `property_name` on `object`.
         *
         * When possible, eg. when signaling a property change from within the class
         * that registered the property, you should use g_object_notify_by_pspec()
         * instead.
         *
         * Note that emission of the notify signal may be blocked with
         * g_object_freeze_notify(). In this case, the signal emissions are queued
         * and will be emitted (in reverse order) when g_object_thaw_notify() is
         * called.
         * @param pspec
         */
        vfunc_notify(pspec: GObject.ParamSpec): void;
        /**
         * the generic setter for all properties of this type. Should be
         *  overridden for every type with properties. If implementations of
         *  `set_property` don't emit property change notification explicitly, this will
         *  be done implicitly by the type system. However, if the notify signal is
         *  emitted explicitly, the type system will not emit it a second time.
         * @param property_id
         * @param value
         * @param pspec
         */
        vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
        /**
         * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
         * @param id Handler ID of the handler to be disconnected
         */
        disconnect(id: number): void;
        /**
         * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
         * @param properties Object containing the properties to set
         */
        set(properties: { [key: string]: any }): void;
        /**
         * Blocks a handler of an instance so it will not be called during any signal emissions
         * @param id Handler ID of the handler to be blocked
         */
        block_signal_handler(id: number): void;
        /**
         * Unblocks a handler so it will be called again during any signal emissions
         * @param id Handler ID of the handler to be unblocked
         */
        unblock_signal_handler(id: number): void;
        /**
         * Stops a signal's emission by the given signal name. This will prevent the default handler and 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 signatures
        interface SignalSignatures extends GObject.InitiallyUnowned.SignalSignatures {
            'accel-closures-changed': () => void;
            'button-press-event': (arg0: Gdk.EventButton) => boolean | void;
            'button-release-event': (arg0: Gdk.EventButton) => boolean | void;
            'can-activate-accel': (arg0: number) => boolean | void;
            'child-notify': (arg0: GObject.ParamSpec) => void;
            'composited-changed': () => void;
            'configure-event': (arg0: Gdk.EventConfigure) => boolean | void;
            'damage-event': (arg0: Gdk.EventExpose) => boolean | void;
            'delete-event': (arg0: Gdk.Event) => boolean | void;
            destroy: () => void;
            'destroy-event': (arg0: Gdk.Event) => boolean | void;
            'direction-changed': (arg0: TextDirection) => void;
            'drag-begin': (arg0: Gdk.DragContext) => void;
            'drag-data-delete': (arg0: Gdk.DragContext) => void;
            'drag-data-get': (arg0: Gdk.DragContext, arg1: SelectionData, arg2: number, arg3: number) => void;
            'drag-data-received': (
                arg0: Gdk.DragContext,
                arg1: number,
                arg2: number,
                arg3: SelectionData,
                arg4: number,
                arg5: number,
            ) => void;
            'drag-drop': (arg0: Gdk.DragContext, arg1: number, arg2: number, arg3: number) => boolean | void;
            'drag-end': (arg0: Gdk.DragContext) => void;
            'drag-failed': (arg0: Gdk.DragContext, arg1: DragResult) => boolean | void;
            'drag-leave': (arg0: Gdk.DragContext, arg1: number) => void;
            'drag-motion': (arg0: Gdk.DragContext, arg1: number, arg2: number, arg3: number) => boolean | void;
            draw: (arg0: cairo.Context) => boolean | void;
            'enter-notify-event': (arg0: Gdk.EventCrossing) => boolean | void;
            event: (arg0: Gdk.Event) => boolean | void;
            'event-after': (arg0: Gdk.Event) => void;
            focus: (arg0: DirectionType) => boolean | void;
            'focus-in-event': (arg0: Gdk.EventFocus) => boolean | void;
            'focus-out-event': (arg0: Gdk.EventFocus) => boolean | void;
            'grab-broken-event': (arg0: Gdk.EventGrabBroken) => boolean | void;
            'grab-focus': () => void;
            'grab-notify': (arg0: boolean) => void;
            hide: () => void;
            'hierarchy-changed': (arg0: Widget | null) => void;
            'key-press-event': (arg0: Gdk.EventKey) => boolean | void;
            'key-release-event': (arg0: Gdk.EventKey) => boolean | void;
            'keynav-failed': (arg0: DirectionType) => boolean | void;
            'leave-notify-event': (arg0: Gdk.EventCrossing) => boolean | void;
            map: () => void;
            'map-event': (arg0: Gdk.EventAny) => boolean | void;
            'mnemonic-activate': (arg0: boolean) => boolean | void;
            'motion-notify-event': (arg0: Gdk.EventMotion) => boolean | void;
            'move-focus': (arg0: DirectionType) => void;
            'parent-set': (arg0: Widget | null) => void;
            'popup-menu': () => boolean | void;
            'property-notify-event': (arg0: Gdk.EventProperty) => boolean | void;
            'proximity-in-event': (arg0: Gdk.EventProximity) => boolean | void;
            'proximity-out-event': (arg0: Gdk.EventProximity) => boolean | void;
            'query-tooltip': (arg0: number, arg1: number, arg2: boolean, arg3: Tooltip) => boolean | void;
            realize: () => void;
            'screen-changed': (arg0: Gdk.Screen | null) => void;
            'scroll-event': (arg0: Gdk.EventScroll) => boolean | void;
            'selection-clear-event': (arg0: Gdk.EventSelection) => boolean | void;
            'selection-get': (arg0: SelectionData, arg1: number, arg2: number) => void;
            'selection-notify-event': (arg0: Gdk.EventSelection) => boolean | void;
            'selection-received': (arg0: SelectionData, arg1: number) => void;
            'selection-request-event': (arg0: Gdk.EventSelection) => boolean | void;
            show: () => void;
            'show-help': (arg0: WidgetHelpType) => boolean | void;
            'size-allocate': (arg0: Allocation) => void;
            'state-changed': (arg0: StateType) => void;
            'state-flags-changed': (arg0: StateFlags) => void;
            'style-set': (arg0: Style | null) => void;
            'style-updated': () => void;
            'touch-event': (arg0: Gdk.Event) => boolean | void;
            unmap: () => void;
            'unmap-event': (arg0: Gdk.EventAny) => boolean | void;
            unrealize: () => void;
            'visibility-notify-event': (arg0: Gdk.EventVisibility) => boolean | void;
            'window-state-event': (arg0: Gdk.EventWindowState) => boolean | void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => void;
            'child-notify::app-paintable': (arg0: GObject.ParamSpec) => void;
            'child-notify::can-default': (arg0: GObject.ParamSpec) => void;
            'child-notify::can-focus': (arg0: GObject.ParamSpec) => void;
            'child-notify::composite-child': (arg0: GObject.ParamSpec) => void;
            'child-notify::double-buffered': (arg0: GObject.ParamSpec) => void;
            'child-notify::events': (arg0: GObject.ParamSpec) => void;
            'child-notify::expand': (arg0: GObject.ParamSpec) => void;
            'child-notify::focus-on-click': (arg0: GObject.ParamSpec) => void;
            'child-notify::halign': (arg0: GObject.ParamSpec) => void;
            'child-notify::has-default': (arg0: GObject.ParamSpec) => void;
            'child-notify::has-focus': (arg0: GObject.ParamSpec) => void;
            'child-notify::has-tooltip': (arg0: GObject.ParamSpec) => void;
            'child-notify::height-request': (arg0: GObject.ParamSpec) => void;
            'child-notify::hexpand': (arg0: GObject.ParamSpec) => void;
            'child-notify::hexpand-set': (arg0: GObject.ParamSpec) => void;
            'child-notify::is-focus': (arg0: GObject.ParamSpec) => void;
            'child-notify::margin': (arg0: GObject.ParamSpec) => void;
            'child-notify::margin-bottom': (arg0: GObject.ParamSpec) => void;
            'child-notify::margin-end': (arg0: GObject.ParamSpec) => void;
            'child-notify::margin-left': (arg0: GObject.ParamSpec) => void;
            'child-notify::margin-right': (arg0: GObject.ParamSpec) => void;
            'child-notify::margin-start': (arg0: GObject.ParamSpec) => void;
            'child-notify::margin-top': (arg0: GObject.ParamSpec) => void;
            'child-notify::name': (arg0: GObject.ParamSpec) => void;
            'child-notify::no-show-all': (arg0: GObject.ParamSpec) => void;
            'child-notify::opacity': (arg0: GObject.ParamSpec) => void;
            'child-notify::parent': (arg0: GObject.ParamSpec) => void;
            'child-notify::receives-default': (arg0: GObject.ParamSpec) => void;
            'child-notify::scale-factor': (arg0: GObject.ParamSpec) => void;
            'child-notify::sensitive': (arg0: GObject.ParamSpec) => void;
            'child-notify::style': (arg0: GObject.ParamSpec) => void;
            'child-notify::tooltip-markup': (arg0: GObject.ParamSpec) => void;
            'child-notify::tooltip-text': (arg0: GObject.ParamSpec) => void;
            'child-notify::valign': (arg0: GObject.ParamSpec) => void;
            'child-notify::vexpand': (arg0: GObject.ParamSpec) => void;
            'child-notify::vexpand-set': (arg0: GObject.ParamSpec) => void;
            'child-notify::visible': (arg0: GObject.ParamSpec) => void;
            'child-notify::width-request': (arg0: GObject.ParamSpec) => void;
            'child-notify::window': (arg0: GObject.ParamSpec) => void;
        }

        // 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;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Widget.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<Widget.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof Widget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Widget.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Widget.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Widget.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Widget.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Widget.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends Accessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // Constructor properties interface

        interface ConstructorProps extends Accessible.ConstructorProps, Atk.Component.ConstructorProps {}
    }

    class WidgetAccessible extends Accessible implements Atk.Component {
        static $gtype: GObject.GType<WidgetAccessible>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: WidgetAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<WidgetAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof WidgetAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, WidgetAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof WidgetAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, WidgetAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof WidgetAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<WidgetAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 signatures
        interface SignalSignatures extends Bin.SignalSignatures {
            'activate-default': () => void;
            'activate-focus': () => void;
            'enable-debugging': (arg0: boolean) => boolean | void;
            'keys-changed': () => void;
            'set-focus': (arg0: Widget | null) => void;
            'notify::accept-focus': (pspec: GObject.ParamSpec) => void;
            'notify::application': (pspec: GObject.ParamSpec) => void;
            'notify::attached-to': (pspec: GObject.ParamSpec) => void;
            'notify::decorated': (pspec: GObject.ParamSpec) => void;
            'notify::default-height': (pspec: GObject.ParamSpec) => void;
            'notify::default-width': (pspec: GObject.ParamSpec) => void;
            'notify::deletable': (pspec: GObject.ParamSpec) => void;
            'notify::destroy-with-parent': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-map': (pspec: GObject.ParamSpec) => void;
            'notify::focus-visible': (pspec: GObject.ParamSpec) => void;
            'notify::gravity': (pspec: GObject.ParamSpec) => void;
            'notify::has-resize-grip': (pspec: GObject.ParamSpec) => void;
            'notify::has-toplevel-focus': (pspec: GObject.ParamSpec) => void;
            'notify::hide-titlebar-when-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::icon': (pspec: GObject.ParamSpec) => void;
            'notify::icon-name': (pspec: GObject.ParamSpec) => void;
            'notify::is-active': (pspec: GObject.ParamSpec) => void;
            'notify::is-maximized': (pspec: GObject.ParamSpec) => void;
            'notify::mnemonics-visible': (pspec: GObject.ParamSpec) => void;
            'notify::modal': (pspec: GObject.ParamSpec) => void;
            'notify::resizable': (pspec: GObject.ParamSpec) => void;
            'notify::resize-grip-visible': (pspec: GObject.ParamSpec) => void;
            'notify::role': (pspec: GObject.ParamSpec) => void;
            'notify::screen': (pspec: GObject.ParamSpec) => void;
            'notify::skip-pager-hint': (pspec: GObject.ParamSpec) => void;
            'notify::skip-taskbar-hint': (pspec: GObject.ParamSpec) => void;
            'notify::startup-id': (pspec: GObject.ParamSpec) => void;
            'notify::title': (pspec: GObject.ParamSpec) => void;
            'notify::transient-for': (pspec: GObject.ParamSpec) => void;
            'notify::type': (pspec: GObject.ParamSpec) => void;
            'notify::type-hint': (pspec: GObject.ParamSpec) => void;
            'notify::urgency-hint': (pspec: GObject.ParamSpec) => void;
            'notify::window-position': (pspec: GObject.ParamSpec) => void;
            'notify::border-width': (pspec: GObject.ParamSpec) => void;
            'notify::child': (pspec: GObject.ParamSpec) => void;
            'notify::resize-mode': (pspec: GObject.ParamSpec) => void;
            'notify::app-paintable': (pspec: GObject.ParamSpec) => void;
            'notify::can-default': (pspec: GObject.ParamSpec) => void;
            'notify::can-focus': (pspec: GObject.ParamSpec) => void;
            'notify::composite-child': (pspec: GObject.ParamSpec) => void;
            'notify::double-buffered': (pspec: GObject.ParamSpec) => void;
            'notify::events': (pspec: GObject.ParamSpec) => void;
            'notify::expand': (pspec: GObject.ParamSpec) => void;
            'notify::focus-on-click': (pspec: GObject.ParamSpec) => void;
            'notify::halign': (pspec: GObject.ParamSpec) => void;
            'notify::has-default': (pspec: GObject.ParamSpec) => void;
            'notify::has-focus': (pspec: GObject.ParamSpec) => void;
            'notify::has-tooltip': (pspec: GObject.ParamSpec) => void;
            'notify::height-request': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand': (pspec: GObject.ParamSpec) => void;
            'notify::hexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::is-focus': (pspec: GObject.ParamSpec) => void;
            'notify::margin': (pspec: GObject.ParamSpec) => void;
            'notify::margin-bottom': (pspec: GObject.ParamSpec) => void;
            'notify::margin-end': (pspec: GObject.ParamSpec) => void;
            'notify::margin-left': (pspec: GObject.ParamSpec) => void;
            'notify::margin-right': (pspec: GObject.ParamSpec) => void;
            'notify::margin-start': (pspec: GObject.ParamSpec) => void;
            'notify::margin-top': (pspec: GObject.ParamSpec) => void;
            'notify::name': (pspec: GObject.ParamSpec) => void;
            'notify::no-show-all': (pspec: GObject.ParamSpec) => void;
            'notify::opacity': (pspec: GObject.ParamSpec) => void;
            'notify::parent': (pspec: GObject.ParamSpec) => void;
            'notify::receives-default': (pspec: GObject.ParamSpec) => void;
            'notify::scale-factor': (pspec: GObject.ParamSpec) => void;
            'notify::sensitive': (pspec: GObject.ParamSpec) => void;
            'notify::style': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-markup': (pspec: GObject.ParamSpec) => void;
            'notify::tooltip-text': (pspec: GObject.ParamSpec) => void;
            'notify::valign': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand': (pspec: GObject.ParamSpec) => void;
            'notify::vexpand-set': (pspec: GObject.ParamSpec) => void;
            'notify::visible': (pspec: GObject.ParamSpec) => void;
            'notify::width-request': (pspec: GObject.ParamSpec) => void;
            'notify::window': (pspec: GObject.ParamSpec) => 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);

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: Window.SignalSignatures;

        // Fields

        bin: Bin;

        // Constructors

        constructor(properties?: Partial<Window.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](type: WindowType): Window;

        // Signals

        connect<K extends keyof Window.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Window.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof Window.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, Window.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof Window.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<Window.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): 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 {
        // Signal signatures
        interface SignalSignatures extends ContainerAccessible.SignalSignatures {
            'notify::widget': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-layer': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-component-mdi-zorder': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-help-text': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-hypertext-nlinks': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-id': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-name': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-parent': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-role': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-caption-object': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-column-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-description': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-row-header': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-table-summary': (pspec: GObject.ParamSpec) => void;
            'notify::accessible-value': (pspec: GObject.ParamSpec) => void;
        }

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: WindowAccessible.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<WindowAccessible.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        // Signals

        connect<K extends keyof WindowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, WindowAccessible.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof WindowAccessible.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, WindowAccessible.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof WindowAccessible.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<WindowAccessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...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 {
        // Signal signatures
        interface SignalSignatures extends GObject.Object.SignalSignatures {}

        // 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>;

        /**
         * Compile-time signal type information.
         *
         * This instance property is generated only for TypeScript type checking.
         * It is not defined at runtime and should not be accessed in JS code.
         * @internal
         */
        $signals: WindowGroup.SignalSignatures;

        // Constructors

        constructor(properties?: Partial<WindowGroup.ConstructorProps>, ...args: any[]);

        _init(...args: any[]): void;

        static ['new'](): WindowGroup;

        // Signals

        connect<K extends keyof WindowGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, WindowGroup.SignalSignatures[K]>,
        ): number;
        connect(signal: string, callback: (...args: any[]) => any): number;
        connect_after<K extends keyof WindowGroup.SignalSignatures>(
            signal: K,
            callback: GObject.SignalCallback<this, WindowGroup.SignalSignatures[K]>,
        ): number;
        connect_after(signal: string, callback: (...args: any[]) => any): number;
        emit<K extends keyof WindowGroup.SignalSignatures>(
            signal: K,
            ...args: GObject.GjsParameters<WindowGroup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
        ): void;
        emit(signal: string, ...args: any[]): void;

        // 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(): string;
        /**
         * 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;

// END